Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > comp.lang.c++ > #124392 > unrolled thread

Viswath & Charmaigne (vector-wide scalar-word and character machines)

Back to article view | Back to comp.lang.c++

Contents

  Viswath & Charmaigne (vector-wide scalar-word and character machines) Ross Finlayson <ross.a.finlayson@gmail.com> - 2026-07-27 11:43 -0700
    Re: Viswath & Charmaigne (vector-wide scalar-word and character machines) Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> - 2026-07-28 02:47 +0800
      Re: Viswath & Charmaigne (vector-wide scalar-word and character machines) Ross Finlayson <ross.a.finlayson@gmail.com> - 2026-07-27 15:07 -0700
        Re: Viswath & Charmaigne (vector-wide scalar-word and character machines) Mild Shock <janburse@fastmail.fm> - 2026-07-28 00:25 +0200
          Re: Viswath & Charmaigne (vector-wide scalar-word and character machines) Ross Finlayson <ross.a.finlayson@gmail.com> - 2026-07-27 16:09 -0700
            Re: Viswath & Charmaigne (vector-wide scalar-word and character machines) Ross Finlayson <ross.a.finlayson@gmail.com> - 2026-07-27 16:33 -0700
          Re: Viswath & Charmaigne (vector-wide scalar-word and character machines) Ross Finlayson <ross.a.finlayson@gmail.com> - 2026-07-27 15:48 -0700
        Re: Viswath & Charmaigne (vector-wide scalar-word and character machines) Ross Finlayson <ross.a.finlayson@gmail.com> - 2026-07-29 07:44 -0700
          You are still chewing on SIMD. LoL (Was: Viswath & Charmaigne) Mild Shock <janburse@fastmail.fm> - 2026-07-29 17:11 +0200
            Re: You are still chewing on SIMD. LoL (Was: Viswath & Charmaigne) Ross Finlayson <ross.a.finlayson@gmail.com> - 2026-07-29 08:25 -0700
              Re: You are still chewing on SIMD. LoL (Was: Viswath & Charmaigne) Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> - 2026-07-29 23:49 +0800
                Re: You are still chewing on SIMD. LoL (Was: Viswath & Charmaigne) Ross Finlayson <ross.a.finlayson@gmail.com> - 2026-07-29 08:59 -0700
                I don't care about Java, pi-WAM is pi-calculus and WAM (Re: You are still chewing on SIMD. LoL) Mild Shock <janburse@fastmail.fm> - 2026-07-29 18:05 +0200
                  Underneath pi-WAM is Hack VM, you can goto (Was: I don't care about Java, pi-WAM is pi-calculus and WAM) Mild Shock <janburse@fastmail.fm> - 2026-07-29 18:09 +0200
                    New addition to π-WAM is π-WAM Assembly (Was: Underneath pi-WAM is Hack VM, you can goto) Mild Shock <janburse@fastmail.fm> - 2026-08-09 19:45 +0200
                  Re: I don't care about Java, pi-WAM is pi-calculus and WAM (Re: You are still chewing on SIMD. LoL) Ross Finlayson <ross.a.finlayson@gmail.com> - 2026-07-29 09:11 -0700
                    A yellow mustard called Rossy Body (Was: I don't care about Java, pi-WAM is pi-calculus and WAM) Mild Shock <janburse@fastmail.fm> - 2026-07-29 18:30 +0200
                      Ignoramus or Ignorabimus: I don't care (π-WAM) (Was: A yellow mustard called Rossy Body) Mild Shock <janburse@fastmail.fm> - 2026-07-29 18:31 +0200
            Hurry Rossy Boy, the blue bus is waiting (Was: You are still chewing on SIMD. LoL) Mild Shock <janburse@fastmail.fm> - 2026-07-29 17:32 +0200
              Re: Hurry Rossy Boy, the blue bus is waiting (Was: You are still chewing on SIMD. LoL) Ross Finlayson <ross.a.finlayson@gmail.com> - 2026-07-29 08:36 -0700
              Look how they advertized CUDA and logical threads (Was: Hurry Rossy Boy, the blue bus is waiting) Mild Shock <janburse@fastmail.fm> - 2026-07-29 17:43 +0200
                Forget any arithmetization of product FSA (Was: Look how they advertized CUDA and logical threads) Mild Shock <janburse@fastmail.fm> - 2026-07-29 17:47 +0200
                  comp.lang.lisp (was: Re: Forget any arithmetization of product FSA) Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> - 2026-07-29 23:53 +0800
                Re: Look how they advertized CUDA and logical threads (Was: Hurry Rossy Boy, the blue bus is waiting) Ross Finlayson <ross.a.finlayson@gmail.com> - 2026-07-29 08:53 -0700
            There are two versions of Hack VM (Was: You are still chewing on SIMD. LoL) Mild Shock <janburse@fastmail.fm> - 2026-07-29 18:14 +0200
              Hack VM has also a Prolog spec (Was: There are two versions of Hack VM) Mild Shock <janburse@fastmail.fm> - 2026-07-29 18:17 +0200
                A better compiler is planned / What do you target? (Was: Hack VM has also a Prolog spec) Mild Shock <janburse@fastmail.fm> - 2026-07-29 18:22 +0200
                  It’s called . . . . enshittification (About the price tag for using a multifile/1) Mild Shock <janburse@fastmail.fm> - 2026-08-14 00:50 +0200
            Budget AI Laptop 2026 versus Cray T3D 1995 (Re: You are still chewing on SIMD. LoL) Mild Shock <janburse@fastmail.fm> - 2026-08-05 14:24 +0200
      A brain desease of 20 days [Rossy Boy] (Was: Viswath & Charmaigne (vector-wide scalar-word and character machines)) Mild Shock <janburse@fastmail.fm> - 2026-07-29 18:38 +0200
        Rossy Boys tears could cool a data center [pi-WAM Interleaved Synchronized Emulator] Mild Shock <janburse@fastmail.fm> - 2026-07-29 20:05 +0200
          Re: Rossy Boys tears could cool a data center [pi-WAM Interleaved Synchronized Emulator] Ross Finlayson <ross.a.finlayson@gmail.com> - 2026-07-29 11:13 -0700
            I don't use Rust, you are crazy [Jump off a bridge, idiot] (Was: Rossy Boys tears could cool a data center [pi-WAM Interleaved Synchronized Emulator]) Mild Shock <janburse@fastmail.fm> - 2026-07-29 20:22 +0200
              Standing on the shoulders of giants (Re: I don't use Rust, you are crazy [Jump off a bridge, idiot]) Mild Shock <janburse@fastmail.fm> - 2026-08-04 03:20 +0200
                You Thief! Stealing Szemeredi, Aristotle, Leibniz, etc.. (Re: Standing on the shoulders of giants) Mild Shock <janburse@fastmail.fm> - 2026-08-04 15:18 +0200
                  How Rossy Boys plagiarism works [Copy Paste Slop] (Re: You Thief! Stealing Szemeredi, Aristotle, Leibniz, etc..) Mild Shock <janburse@fastmail.fm> - 2026-08-04 17:56 +0200
            Postgres is in C! Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> - 2026-07-30 03:46 +0800
              Re: Postgres is in C! Ross Finlayson <ross.a.finlayson@gmail.com> - 2026-07-29 13:47 -0700
                Please don't extend your cross posting / What does abstract mean? (Was: Postgres is in C!) Mild Shock <janburse@fastmail.fm> - 2026-07-29 23:00 +0200
                  Re: Please don't extend your cross posting / What does abstract mean? (Was: Postgres is in C!) Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> - 2026-07-30 21:05 +0800
                    Re: Please don't extend your cross posting / What does abstract mean? (Was: Postgres is in C!) scott@slp53.sl.home (Scott Lurndal) - 2026-07-30 14:46 +0000
                    Re: Please don't extend your cross posting / What does abstract mean? Cóilín Nioclásín Glostéir <thanks-to@Taf.com> - 2026-07-30 16:00 +0000
                Please don't extend your cross posting / What does abstract mean? (Was: Postgres is in C!) Mild Shock <janburse@fastmail.fm> - 2026-07-29 23:05 +0200
                Mars, the MIPS emulator in Java (was: Re: Postgres is in C!) Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> - 2026-07-30 21:20 +0800
                  Re: Mars, the MIPS emulator in Java Ross Finlayson <ross.a.finlayson@gmail.com> - 2026-07-30 06:59 -0700
                    Re: Mars, the MIPS emulator in Java Ross Finlayson <ross.a.finlayson@gmail.com> - 2026-07-30 07:24 -0700
                      Re: Mars, the MIPS emulator in Java Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> - 2026-08-05 09:58 +0800
                    Re: Mars, the MIPS emulator in Java Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> - 2026-07-30 23:19 +0800
                      Re: Mars, the MIPS emulator in Java Ross Finlayson <ross.a.finlayson@gmail.com> - 2026-07-30 09:23 -0700
                        Re: Mars, the MIPS emulator in Java Ross Finlayson <ross.a.finlayson@gmail.com> - 2026-07-30 09:36 -0700
                          Decorum (was: Re: Mars, the MIPS emulator in Java) Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> - 2026-07-31 23:07 +0800
                            Re: Decorum Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> - 2026-07-31 23:09 +0800
                            Re: Decorum Ross Finlayson <ross.a.finlayson@gmail.com> - 2026-07-31 08:36 -0700
                              Re: Decorum Ross Finlayson <ross.a.finlayson@gmail.com> - 2026-07-31 08:44 -0700
                              Re: Decorum Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> - 2026-08-05 10:38 +0800
                        Re: Mars, the MIPS emulator in Java Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> - 2026-08-05 10:15 +0800
                          Re: Mars, the MIPS emulator in Java Ross Finlayson <ross.a.finlayson@gmail.com> - 2026-08-04 23:31 -0700
                            Re: Mars, the MIPS emulator in Java "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2026-08-05 12:42 -0700
                              Re: Mars, the MIPS emulator in Java Ross Finlayson <ross.a.finlayson@gmail.com> - 2026-08-05 13:24 -0700
                                Re: Mars, the MIPS emulator in Java "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2026-08-05 13:30 -0700
                                Re: Mars, the MIPS emulator in Java Ross Finlayson <ross.a.finlayson@gmail.com> - 2026-08-05 13:45 -0700
                            Re: Mars, the MIPS emulator in Java Ross Finlayson <ross.a.finlayson@gmail.com> - 2026-08-05 20:42 -0700
                              Re: Mars, the MIPS emulator in Java Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> - 2026-08-07 09:55 +0800
                                Re: Mars, the MIPS emulator in Java Ross Finlayson <ross.a.finlayson@gmail.com> - 2026-08-07 05:13 -0700
                                  Re: Mars, the MIPS emulator in Java Ross Finlayson <ross.a.finlayson@gmail.com> - 2026-08-07 05:59 -0700
                            Re: Mars, the MIPS emulator in Java Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> - 2026-08-07 09:53 +0800
                              Re: Mars, the MIPS emulator in Java Ross Finlayson <ross.a.finlayson@gmail.com> - 2026-08-06 20:11 -0700
              Hack ecosystem ignorance paired with paranoia [Nand to Tetris] (Re: Postgres is in C!) Mild Shock <janburse@fastmail.fm> - 2026-07-29 22:49 +0200
                A funny Q16.16 experiment with Hack (Was: Hack ecosystem ignorance paired with paranoia [Nand to Tetris]) Mild Shock <janburse@fastmail.fm> - 2026-07-29 23:10 +0200
                  Summer Challenge: libSQL = Prolog+Modes [VDBE versus π-WAM] (Re: A funny Q16.16 experiment with Hack) Mild Shock <janburse@fastmail.fm> - 2026-07-30 11:27 +0200
                    Re: Bullshit Authorized by Sarah Connor [EyeProlog Failure] (Re: Summer Challenge: libSQL = Prolog+Modes [VDBE versus π-WAM]) Mild Shock <janburse@fastmail.fm> - 2026-08-12 20:30 +0200
                RCan library(ironpaw) repurpose FFT hardware [Glimps into Ryzen AI 7 350] (Re: Hack ecosystem ignorance paired with paranoia) Mild Shock <janburse@fastmail.fm> - 2026-08-01 02:33 +0200
                Can library(ironpaw) repurpose FFT hardware [Glimps into Ryzen AI 7 350] (Re: Hack ecosystem ignorance paired with paranoia) Mild Shock <janburse@fastmail.fm> - 2026-08-01 02:34 +0200
              Turbo Vison, again (was: Re: Postgres is in C!) Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> - 2026-07-30 21:31 +0800
        He uses "FIFO objects", and DMA and Noc [Glimps into Ryzen AI 7 350] (Re: A brain desease of 20 days [Rossy Boy])) Mild Shock <janburse@fastmail.fm> - 2026-08-01 12:15 +0200
          Tablet and phone UBS-C remote debugging (Re: He uses "FIFO objects", and DMA and Noc) Mild Shock <janburse@fastmail.fm> - 2026-08-01 12:18 +0200
            NPUs doing 2d chess comms (Manhattan Distance or L1 Norm) (Re: Tablet and phone UBS-C remote debugging) Mild Shock <janburse@fastmail.fm> - 2026-08-01 14:11 +0200
              NACK retransmission might double Manhattan Distance (Re: NPUs doing 2d chess comms) Mild Shock <janburse@fastmail.fm> - 2026-08-01 14:23 +0200
    Rossy Boy is neither Einstein nor Zweistein (Re: Viswath & Charmaigne) Mild Shock <janburse@fastmail.fm> - 2026-07-27 21:18 +0200
      Re: Rossy Boy is neither Einstein nor Zweistein (Re: Viswath & Charmaigne) Ross Finlayson <ross.a.finlayson@gmail.com> - 2026-07-27 15:35 -0700
        Clueless about MIMD as usual [Flynn's Taxonomy] (Was: Rossy Boy is neither Einstein nor Zweistein) Mild Shock <janburse@fastmail.fm> - 2026-07-28 11:25 +0200
          Re: Clueless about MIMD as usual [Flynn's Taxonomy] (Was: Rossy Boy is neither Einstein nor Zweistein) Ross Finlayson <ross.a.finlayson@gmail.com> - 2026-07-28 20:39 -0700
            confused rossy boy is confused (Was: Clueless about MIMD as usual [Flynn's Taxonomy]) Mild Shock <janburse@fastmail.fm> - 2026-07-29 11:15 +0200
              Gemini, DeepSeek, OpenAI more clever than rossy boy (Was: confused rossy boy is confused) Mild Shock <janburse@fastmail.fm> - 2026-07-29 11:18 +0200
              Re: confused rossy boy is confused (Was: Clueless about MIMD as usual [Flynn's Taxonomy]) Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> - 2026-07-29 17:21 +0800
                In AI Acceleration nobody cares about CivetWeb (Was: confused rossy boy is confused) Mild Shock <janburse@fastmail.fm> - 2026-07-29 11:27 +0200
                  Re: In AI Acceleration nobody cares about CivetWeb (Was: confused rossy boy is confused) Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> - 2026-07-29 17:40 +0800
                    Your strictness is your problem , not mine [See WebLLM] (Was: In AI Acceleration nobody cares about CivetWeb) Mild Shock <janburse@fastmail.fm> - 2026-07-29 11:46 +0200
                      Graphics Processing with Fortran 77 (was: Re: Your strictness is your problem , not mine) Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> - 2026-07-29 18:10 +0800
                        I am not in C, it is theory and C++ [Hybrid Approaches from KOAN/Fortran-S] (Was: Graphics Processing with Fortran 77) Mild Shock <janburse@fastmail.fm> - 2026-07-29 12:43 +0200
                          Java picky concerning JIT-ing [Luckier with C++/C or FORTRAN compilers?] (Re: I am not in C, it is theory and C++) Mild Shock <janburse@fastmail.fm> - 2026-07-29 12:53 +0200
                  Run with minimum HTTPS and .mjs type (Re: In AI Acceleration nobody cares about CivetWeb) Mild Shock <janburse@fastmail.fm> - 2026-07-29 11:48 +0200
                    Lamas in a cradle and Lamas on the edge [Red Pyjama] (Was: Run with minimum HTTPS and .mjs type) Mild Shock <janburse@fastmail.fm> - 2026-07-29 13:05 +0200
                      Synthetic Multilanguage Autoformalization Dataset [Informath project] (Re: Lamas in a cradle and Lamas on the edge [Red Pyjama]) Mild Shock <janburse@fastmail.fm> - 2026-08-08 09:22 +0200
                        Six Proofs and Generally Inteligent Systems [EyeProlog Pseudo Scientism] (Re: Synthetic Multilanguage Autoformalization Dataset [Informath project]) Mild Shock <janburse@fastmail.fm> - 2026-08-15 15:20 +0200
                          Everybody does eat and sleep [The SK hynix Story] (Re: Six Proofs and Generally Inteligent Systems [EyeProlog Pseudo Scientism]) Mild Shock <janburse@fastmail.fm> - 2026-08-15 18:49 +0200
                Re: confused rossy boy is confused (Was: Clueless about MIMD as usual [Flynn's Taxonomy]) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2026-07-29 14:42 -0700
                  Even send_color and recv_color can block [Cerebras Waver] (Was: confused rossy boy is confused) Mild Shock <janburse@fastmail.fm> - 2026-08-02 23:37 +0200
                    Re: Even send_color and recv_color can block [Cerebras Waver] (Was: confused rossy boy is confused) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2026-08-02 14:40 -0700
                      Re: Even send_color and recv_color can block [Cerebras Waver] (Was: confused rossy boy is confused) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2026-08-02 14:43 -0700
                      You don't understand that compute shaders are tasks (Was: Even send_color and recv_color can block [Cerebras Waver]) Mild Shock <janburse@fastmail.fm> - 2026-08-02 23:45 +0200
                      You don't understand that compute shaders are tasks (Re: Even send_color and recv_color can block [Cerebras Waver]) Mild Shock <janburse@fastmail.fm> - 2026-08-02 23:46 +0200
                        Ignoramus / Ignorabimus Barometer: Almost 1 Month (Re: You don't understand that compute shaders are tasks) Mild Shock <janburse@fastmail.fm> - 2026-08-03 00:09 +0200
                          Homework: Game Engine in WebGPU (Re: Ignoramus / Ignorabimus Barometer: Almost 1 Month) Mild Shock <janburse@fastmail.fm> - 2026-08-03 02:08 +0200
                            Re: Homework: Game Engine in WebGPU (Re: Ignoramus / Ignorabimus Barometer: Almost 1 Month) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2026-08-03 11:55 -0700
                              You are not correctly thinking (Was: Homework: Game Engine in WebGPU) Mild Shock <janburse@fastmail.fm> - 2026-08-03 21:04 +0200
                                Re: You are not correctly thinking (Was: Homework: Game Engine in WebGPU) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2026-08-03 12:32 -0700
                                  You don't understand the economy of an AI Laptop (Was: You are not correctly thinking) Mild Shock <janburse@fastmail.fm> - 2026-08-03 22:24 +0200
                                    You don't understand producer , workers , consumer (Was: You don't understand the economy of an AI Laptop ) Mild Shock <janburse@fastmail.fm> - 2026-08-03 22:37 +0200
                                      Re: You don't understand producer , workers , consumer (Was: You don't understand the economy of an AI Laptop ) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2026-08-03 14:29 -0700
                                        Know nothing and forget what you posted day before (Was: You don't understand producer , workers , consumer) Mild Shock <janburse@fastmail.fm> - 2026-08-03 23:38 +0200
    Re: Viswath & Charmaigne (vector-wide scalar-word and character machines) Ross Finlayson <ross.a.finlayson@gmail.com> - 2026-07-30 06:49 -0700
      Re: Viswath & Charmaigne (vector-wide scalar-word and character machines) Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2026-07-30 14:55 -0700
      Re: Viswath & Charmaigne (vector-wide scalar-word and character machines) Ross Finlayson <ross.a.finlayson@gmail.com> - 2026-07-31 12:55 -0700
        Re: Viswath & Charmaigne (vector-wide scalar-word and character machines) Ross Finlayson <ross.a.finlayson@gmail.com> - 2026-07-31 13:05 -0700
    Ljubljana School versus Zurich School (Was: Viswath & Charmaigne) Mild Shock <janburse@fastmail.fm> - 2026-08-03 20:14 +0200
      Re: Ljubljana School versus Zurich School (Was: Viswath & Charmaigne) Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> - 2026-08-04 02:21 +0800
        pi-WAM uses ADA RendezVous (Was: Ljubljana School versus Zurich School) Mild Shock <janburse@fastmail.fm> - 2026-08-03 20:35 +0200
          A spinlock rewrite will be necessary (Was: pi-WAM uses ADA RendezVous) Mild Shock <janburse@fastmail.fm> - 2026-08-03 21:00 +0200
      Big thanks to Ljubljana School [Searching 0xCAFFEE] (Was: Ljubljana School versus Zurich School) Mild Shock <janburse@fastmail.fm> - 2026-08-03 20:40 +0200

Page 1 of 6  [1] 2 3 4 5 6  Next page →

#124392 — Viswath & Charmaigne (vector-wide scalar-word and character machines)

Hello, here I'll post some design notes and a panel discussion with some
chat-bots about making some sense of the "vector-wide scalar word"
and "character machines", on commodity hardware about ubiquitous operations.


It's considered at least tangentially relevant to comp.lang.c and
comp.lang.c++ because for example text is ubiquitous and the targets
would be low-level, while the higher-level languages would have a
same sort of patternry, and for example that libc and cstdlib are
standard, and as with regards to POSIX and Unicode and so on.

Please feel free to excuse or ignore, or comment as freely.

Thanks for reading.

[toc] | [next] | [standalone]

#124393

On 28/07/2026 2:43 AM, Ross Finlayson wrote:
> Hello, here I'll post some design notes and a panel discussion with some
> chat-bots about making some sense of the "vector-wide scalar word"
> and "character machines", on commodity hardware about ubiquitous 
> operations.
> 
> 
> It's considered at least tangentially relevant to comp.lang.c and
> comp.lang.c++ because for example text is ubiquitous and the targets
> would be low-level, while the higher-level languages would have a
> same sort of patternry, and for example that libc and cstdlib are
> standard, and as with regards to POSIX and Unicode and so on.
> 
> Please feel free to excuse or ignore, or comment as freely.
> 
> Thanks for reading.
> 

Are you generating all of your code via LLMs?  Rest assured,
the LLM generated code will have subtle and sometimes not so subtle
bugs.


Happy bughunting!
-- 
Johann | email: invalid -> com | http://www.myrkraverk.com/blog/
I'm not from the Internet, I just work there. | via Easynews.com

[toc] | [prev] | [next] | [standalone]

#124395

On 07/27/2026 11:47 AM, Johann 'Myrkraverk' Oskarsson wrote:
> On 28/07/2026 2:43 AM, Ross Finlayson wrote:
>> Hello, here I'll post some design notes and a panel discussion with some
>> chat-bots about making some sense of the "vector-wide scalar word"
>> and "character machines", on commodity hardware about ubiquitous
>> operations.
>>
>>
>> It's considered at least tangentially relevant to comp.lang.c and
>> comp.lang.c++ because for example text is ubiquitous and the targets
>> would be low-level, while the higher-level languages would have a
>> same sort of patternry, and for example that libc and cstdlib are
>> standard, and as with regards to POSIX and Unicode and so on.
>>
>> Please feel free to excuse or ignore, or comment as freely.
>>
>> Thanks for reading.
>>
>
> Are you generating all of your code via LLMs?  Rest assured,
> the LLM generated code will have subtle and sometimes not so subtle
> bugs.
>
>
> Happy bughunting!

Heh, no, I write my own code, yet, words are words and those agree.

[toc] | [prev] | [next] | [standalone]

#124396

Hi,

There is doubt, that you write code.
How do you write code, with your
asshole? I mean you even don't under-

stand a simple LIPS budget post?

Bye

Ross Finlayson schrieb:
> On 07/27/2026 11:47 AM, Johann 'Myrkraverk' Oskarsson wrote:
>> On 28/07/2026 2:43 AM, Ross Finlayson wrote:
>>> Hello, here I'll post some design notes and a panel discussion with some
>>> chat-bots about making some sense of the "vector-wide scalar word"
>>> and "character machines", on commodity hardware about ubiquitous
>>> operations.
>>>
>>>
>>> It's considered at least tangentially relevant to comp.lang.c and
>>> comp.lang.c++ because for example text is ubiquitous and the targets
>>> would be low-level, while the higher-level languages would have a
>>> same sort of patternry, and for example that libc and cstdlib are
>>> standard, and as with regards to POSIX and Unicode and so on.
>>>
>>> Please feel free to excuse or ignore, or comment as freely.
>>>
>>> Thanks for reading.
>>>
>>
>> Are you generating all of your code via LLMs?  Rest assured,
>> the LLM generated code will have subtle and sometimes not so subtle
>> bugs.
>>
>>
>> Happy bughunting!
> 
> Heh, no, I write my own code, yet, words are words and those agree.
> 
> 

[toc] | [prev] | [next] | [standalone]

#124398

On 07/27/2026 03:48 PM, Ross Finlayson wrote:
> On 07/27/2026 03:25 PM, Mild Shock wrote:
>> Hi,
>>
>> There is doubt, that you write code.
>> How do you write code, with your
>> asshole? I mean you even don't under-
>>
>> stand a simple LIPS budget post?
>>
>> Bye
>>
>> Ross Finlayson schrieb:
>>> On 07/27/2026 11:47 AM, Johann 'Myrkraverk' Oskarsson wrote:
>>>> On 28/07/2026 2:43 AM, Ross Finlayson wrote:
>>>>> Hello, here I'll post some design notes and a panel discussion with
>>>>> some
>>>>> chat-bots about making some sense of the "vector-wide scalar word"
>>>>> and "character machines", on commodity hardware about ubiquitous
>>>>> operations.
>>>>>
>>>>>
>>>>> It's considered at least tangentially relevant to comp.lang.c and
>>>>> comp.lang.c++ because for example text is ubiquitous and the targets
>>>>> would be low-level, while the higher-level languages would have a
>>>>> same sort of patternry, and for example that libc and cstdlib are
>>>>> standard, and as with regards to POSIX and Unicode and so on.
>>>>>
>>>>> Please feel free to excuse or ignore, or comment as freely.
>>>>>
>>>>> Thanks for reading.
>>>>>
>>>>
>>>> Are you generating all of your code via LLMs?  Rest assured,
>>>> the LLM generated code will have subtle and sometimes not so subtle
>>>> bugs.
>>>>
>>>>
>>>> Happy bughunting!
>>>
>>> Heh, no, I write my own code, yet, words are words and those agree.
>>>
>>>
>>
>
> Perhaps take a look on comp.lang.java.programmer, for example
> where is given a simple way to make "Web APIs" in "Java",
> with cool elite tech like "JSON" and "HTTP".
>
> "APIs", I learned that word in 1994 working at "The Electronic Messaging
> Association", which no longer so much exists
> in its current form.
>
> Most of my code is doing work in prod, and has been for
> decades, long after I logged out one of my dozens of aliases,
> I even wrote a few lines of code in Windows, though I
> lean more toward HP and Micron than Microsoft and NVIDIA.
>
> I've written frameworks in front-end and back-end,
> and about system code and theory,
> and around the whole damn stack.
>
> "These motes excitate a mouse brain immensely".
>
>
>
> Anyways, about "vectorizing string functions"
> and "vectorizing regular expressions"
> and "vectorizing parsers", that's what Viswath & Charmaigne is about,
> I'd be curious your inputs if you can ignore the trolls,
> like the sock-puppet farm here. It's basically figured useful
> for, for example, deep inspection of Internet messages, or incremental
> parsing, when implementing the text Internet protocols.
>
>
> Then, yes, it's not so relevant to "the Foundations of Mathematics
> and Physics", directly, yet it is to systems programming.
>
>
>


"When compiling legacy PTX code (ISA versions prior to 3.0)
containing [...], the compiler silently disables use of the ABI."

"Would you like to buy a bridge that's also a boat?
It's rocking all over the place."

The specs and stable, backward compatible definitions of modern
commodity CPUs are around, people even collect them over time, they're
even in PDFs, in case you want to read one without looking over your own
electronic shoulder.

Which defines the ABI, ....

[toc] | [prev] | [next] | [standalone]

#124400

On 07/27/2026 04:09 PM, Ross Finlayson wrote:
> On 07/27/2026 03:48 PM, Ross Finlayson wrote:
>> On 07/27/2026 03:25 PM, Mild Shock wrote:
>>> Hi,
>>>
>>> There is doubt, that you write code.
>>> How do you write code, with your
>>> asshole? I mean you even don't under-
>>>
>>> stand a simple LIPS budget post?
>>>
>>> Bye
>>>
>>> Ross Finlayson schrieb:
>>>> On 07/27/2026 11:47 AM, Johann 'Myrkraverk' Oskarsson wrote:
>>>>> On 28/07/2026 2:43 AM, Ross Finlayson wrote:
>>>>>> Hello, here I'll post some design notes and a panel discussion with
>>>>>> some
>>>>>> chat-bots about making some sense of the "vector-wide scalar word"
>>>>>> and "character machines", on commodity hardware about ubiquitous
>>>>>> operations.
>>>>>>
>>>>>>
>>>>>> It's considered at least tangentially relevant to comp.lang.c and
>>>>>> comp.lang.c++ because for example text is ubiquitous and the targets
>>>>>> would be low-level, while the higher-level languages would have a
>>>>>> same sort of patternry, and for example that libc and cstdlib are
>>>>>> standard, and as with regards to POSIX and Unicode and so on.
>>>>>>
>>>>>> Please feel free to excuse or ignore, or comment as freely.
>>>>>>
>>>>>> Thanks for reading.
>>>>>>
>>>>>
>>>>> Are you generating all of your code via LLMs?  Rest assured,
>>>>> the LLM generated code will have subtle and sometimes not so subtle
>>>>> bugs.
>>>>>
>>>>>
>>>>> Happy bughunting!
>>>>
>>>> Heh, no, I write my own code, yet, words are words and those agree.
>>>>
>>>>
>>>
>>
>> Perhaps take a look on comp.lang.java.programmer, for example
>> where is given a simple way to make "Web APIs" in "Java",
>> with cool elite tech like "JSON" and "HTTP".
>>
>> "APIs", I learned that word in 1994 working at "The Electronic Messaging
>> Association", which no longer so much exists
>> in its current form.
>>
>> Most of my code is doing work in prod, and has been for
>> decades, long after I logged out one of my dozens of aliases,
>> I even wrote a few lines of code in Windows, though I
>> lean more toward HP and Micron than Microsoft and NVIDIA.
>>
>> I've written frameworks in front-end and back-end,
>> and about system code and theory,
>> and around the whole damn stack.
>>
>> "These motes excitate a mouse brain immensely".
>>
>>
>>
>> Anyways, about "vectorizing string functions"
>> and "vectorizing regular expressions"
>> and "vectorizing parsers", that's what Viswath & Charmaigne is about,
>> I'd be curious your inputs if you can ignore the trolls,
>> like the sock-puppet farm here. It's basically figured useful
>> for, for example, deep inspection of Internet messages, or incremental
>> parsing, when implementing the text Internet protocols.
>>
>>
>> Then, yes, it's not so relevant to "the Foundations of Mathematics
>> and Physics", directly, yet it is to systems programming.
>>
>>
>>
>
>
> "When compiling legacy PTX code (ISA versions prior to 3.0)
> containing [...], the compiler silently disables use of the ABI."
>
> "Would you like to buy a bridge that's also a boat?
> It's rocking all over the place."
>
> The specs and stable, backward compatible definitions of modern
> commodity CPUs are around, people even collect them over time, they're
> even in PDFs, in case you want to read one without looking over your own
> electronic shoulder.
>
> Which defines the ABI, ....
>
>



"Arrays of all types can be declared,
and the identifier becomes an address constant
in the space where the array is declared.
The size of the array is a constant in the program.

Array elements can be accessed using an explicitly calculated byte address,
or by indexing into the array using square-bracket notation.
The expression within square brackets is either a constant integer,
a register variable, or a simple register with constant offset expression,
where the offset is a constant expression that is either added or
subtracted from a register variable. If more complicated indexing
is desired, it must be written as an address calculation prior to use."


Sounds pretty familiar, ..., then textures in graphics cards since
triangles per second are like memory segments, ..., in case you
ever read "Graphics Gems" or "Foley and Van Dam".

"A tensor is a multi-dimensional matrix structure in the memory.
Tensor is defined by the following properties:
Dimensionality
Dimension sizes across each dimension
Individual element types
Tensor stride across each dimension

PTX supports instructions which can operate on the tensor data.
PTX Tensor instructions include:
Copying data between global and shared memories
Reducing the destination tensor data with the source.

The Tensor data can be operated on by various wmma.mma,
mma and wgmma.mma_async instructions.

PTX Tensor instructions treat the tensor data
in the global memory as a multi-dimensional
structure and treat the data in the shared memory as a linear data."



Well, if that's a, "PTX tensor", data type,
that's not all what any tensors are, those are
a kind of tensor, yet, mostly they're multi-dimensional
arrays with stride built into computing for corner and edge cases,
about stride and stribe and striqe and stripe,
so you don't have to think y * h + x,
instead just calling it "x, y, z, ..." up to a grand-total
of a five-dimension non-ragged array,
just like C's.

"Tensor" sounds cool, I guess "array" was already used.


Of course there's lots of things you can build with that,
like tensorial products and so on, and about matroids
beyond the hypercubes and rows and columns and
pillars and files and i-rows,
matrices and the determinantal analysis.

They're not exactly "tensors", though,
more of a "partial" or "restricted" account.

Wow, and 64kiB memory apiece, ....


Here there's a big interest in text and lots of it,
in a serial sort of order, without too much
attachment or lock-in, yet a stable (and closed) interface.


So, then, yes, for readers in the field interested in
vectorizing (meaning, employing the parallel resources)
of common algorithms of the computers everybody already
has and tomorrow's, also, this is for "normal forms"
and "standard guarantees".

[toc] | [prev] | [next] | [standalone]

#124399

On 07/27/2026 03:25 PM, Mild Shock wrote:
> Hi,
>
> There is doubt, that you write code.
> How do you write code, with your
> asshole? I mean you even don't under-
>
> stand a simple LIPS budget post?
>
> Bye
>
> Ross Finlayson schrieb:
>> On 07/27/2026 11:47 AM, Johann 'Myrkraverk' Oskarsson wrote:
>>> On 28/07/2026 2:43 AM, Ross Finlayson wrote:
>>>> Hello, here I'll post some design notes and a panel discussion with
>>>> some
>>>> chat-bots about making some sense of the "vector-wide scalar word"
>>>> and "character machines", on commodity hardware about ubiquitous
>>>> operations.
>>>>
>>>>
>>>> It's considered at least tangentially relevant to comp.lang.c and
>>>> comp.lang.c++ because for example text is ubiquitous and the targets
>>>> would be low-level, while the higher-level languages would have a
>>>> same sort of patternry, and for example that libc and cstdlib are
>>>> standard, and as with regards to POSIX and Unicode and so on.
>>>>
>>>> Please feel free to excuse or ignore, or comment as freely.
>>>>
>>>> Thanks for reading.
>>>>
>>>
>>> Are you generating all of your code via LLMs?  Rest assured,
>>> the LLM generated code will have subtle and sometimes not so subtle
>>> bugs.
>>>
>>>
>>> Happy bughunting!
>>
>> Heh, no, I write my own code, yet, words are words and those agree.
>>
>>
>

Perhaps take a look on comp.lang.java.programmer, for example
where is given a simple way to make "Web APIs" in "Java",
with cool elite tech like "JSON" and "HTTP".

"APIs", I learned that word in 1994 working at "The Electronic Messaging
Association", which no longer so much exists
in its current form.

Most of my code is doing work in prod, and has been for
decades, long after I logged out one of my dozens of aliases,
I even wrote a few lines of code in Windows, though I
lean more toward HP and Micron than Microsoft and NVIDIA.

I've written frameworks in front-end and back-end,
and about system code and theory,
and around the whole damn stack.

"These motes excitate a mouse brain immensely".



Anyways, about "vectorizing string functions"
and "vectorizing regular expressions"
and "vectorizing parsers", that's what Viswath & Charmaigne is about,
I'd be curious your inputs if you can ignore the trolls,
like the sock-puppet farm here. It's basically figured useful
for, for example, deep inspection of Internet messages, or incremental
parsing, when implementing the text Internet protocols.


Then, yes, it's not so relevant to "the Foundations of Mathematics
and Physics", directly, yet it is to systems programming.

[toc] | [prev] | [next] | [standalone]

#124427

On 07/27/2026 03:07 PM, Ross Finlayson wrote:
> On 07/27/2026 11:47 AM, Johann 'Myrkraverk' Oskarsson wrote:
>> On 28/07/2026 2:43 AM, Ross Finlayson wrote:
>>> Hello, here I'll post some design notes and a panel discussion with some
>>> chat-bots about making some sense of the "vector-wide scalar word"
>>> and "character machines", on commodity hardware about ubiquitous
>>> operations.
>>>
>>>
>>> It's considered at least tangentially relevant to comp.lang.c and
>>> comp.lang.c++ because for example text is ubiquitous and the targets
>>> would be low-level, while the higher-level languages would have a
>>> same sort of patternry, and for example that libc and cstdlib are
>>> standard, and as with regards to POSIX and Unicode and so on.
>>>
>>> Please feel free to excuse or ignore, or comment as freely.
>>>
>>> Thanks for reading.
>>>
>>
>> Are you generating all of your code via LLMs?  Rest assured,
>> the LLM generated code will have subtle and sometimes not so subtle
>> bugs.
>>
>>
>> Happy bughunting!
>
> Heh, no, I write my own code, yet, words are words and those agree.
>
>

viswath-charmaigne-20270727_b.txt

About smearing and unsmearing, it's figured to make for
"smear-detection" and "smear-correction", and for the
"unsmear-detection" and "unsmear-correction", basically that smearing is
indicated by variously:

multiple-byte characters
escape characters and translated characters
control-characters with payloads/bodies

with mostly the case being multiple-byte and escape-translations.

The idea of detection and correction is about comprehension and
expression, about what comprehensions, or classifications, occur,
according to what expressions, have as their implicits the contexts.

So, it's figured that it starts with bytes, then, for source text, first
there are the main or base classes, alnum/punct/white/coded, then, for
coded, it's to be established whether those are non-printable control
characters, which mostly are to be avoided or invalidated unless there
are particular comprehensible payloads representing sub-expressions, or
they're UTF-8 codepoints, which is figured to be the default.


ASCII -> UTF-8?
UCS2 -> BE|LE +BOM? -> UTF-16
UCS2 -> UTF-16?

Then, the idea is that first the source-main class is applied, or, about
there being a proto-class that's "coded and non-coded", and for example
about line-breaks or otherwise field-separators and record-separators.


So, it's figured that for "source" languages it's ASCII-centric, so the
base character classes are loaded first, then the smear/unsmear for
UTF-8 or otherwise the multi-byte is ASCII-peripheral, then that UCS-2
got UTF-16 has a similar account with regards to the smashing,

https://www.autoitconsulting.com/site/development/utf-8-utf-16-text-encoding-detection-library/

(An article suggests to detect UCS2/UTF-16 by looking for the
Byte-Order-Marker, then for newlines, then for a preponderance of ASCII
characters.)

https://en.wikipedia.org/wiki/Charset_detection



So, then presuming UTF-8, then gets back to figuring out smearing and
straddling of smearing, about that UTF-8 bytes get smeared and the masks
for their predicates also get smeared, then when they straddle the
codes-themselves, that the context of the character is carried across
the boundary (splitting/stitching).


About the control-characters, then these are for example the "DEC VT" or
"ECMA-48", "ISO 6429", "DEC STD 070", like from "XTerm control
sequences" by Moy, Gildea, and Dickey, mostly to be avoided, yet
variously where anything that's not a "single-character function", is to
be avoided, and that since SPACE, TAB, NL, CR, FF, VT are considered
white-space not coded, has that coded characters make for invalidation,
though there's a simple enough account that the data following
control-characters with parameters in sequences are detectable.

So, coded/ nybbles are first:

alnum/
punct/
white/

coded/ctrl
coded/utf8
coded/nul
coded/bom

Then, a first-pass over the buffer is always starting with context of
the straddle-stitching whether a UTF-8 character or what kind of
control character its sequence is at what state, that what gets derived
for UTF-8 characters as secondary is either a nybble with the count-total
and count-remaining, or, count-encountered and count-remaining.

1
2
3
4


When straddling, it's un-known whether there are remaining bytes,
about basically to have a separate part of the nybble for the straddle

straddling/
split/
stitching/

The idea is that the smear/unsmearing is indicated by the word, for
the properties, then that for the code-point, that's inserted with
the stitching, about that

splitting is only at the end of a word, and
stitching is only at the beginning of a word

for forward search.

So, first the main class is determined, then, conditioned on whether
there exists either a "max-length" or a null character is the
End-of-Input, and conditioned on whether there's a "Start-of-Input" offset,
about offsets and extents, the main class is determined from the
Start-of-Input (usually somewhere in the initial word) and End-of-Input,
then making the lookup of the main class.

Another point of straddle and splitting and stitching is for the fixed
match case, while it's usually figured that the fixed string being
matched fits within a word, arbitrarily it crosses multiple words or is
more than word length, then that when there's an initial-segment match,
to be matching the trailing-segment. So, in splitting UTF-8 codes, it's
known that the code extends, yet not how far, yet in splitting fixed
strings, it's known that the initial-segment matches, not if the
trailing-segment matches.


Then, matching the "fixed" also gets into matching more
widely, about the expressions and grammars. From taking
a look into outlines of Hyperscan and Vectorscan (regex and
multiple-regex matching engines employing vector techniques
from Intel and ARM respectively), there are notions of the
"decomposition" of expressions, then about what's promontory
and matching the "fixed", first fixed-length then fixed-content,
when matching what would be "longest sub-matches", then
to recursively bridge the definite sub-matches.


So, the context of the findings and matchings start to develop,
with the idea that by the presence in the context, that actions
occur, otherwise for nothing or no-ops.

Afore-Input: Start-of-Input, at the beginning of a "walk", and beginning
of a "word"
Afore-Stitch: at the beginning of a word, there's stitching to occur

After-Split: at the end of a word, there's definitely/possibly a splot
After-Input: End-of-Input, at the end of a "walk", and end of a "word".


Here "walk" has the usual notions of "tree-traversals", that instead
here "walk" (or "work") is the notion here of the sequence action,
then for "work". Then "Afore" and "After", or "Before" and "Behind",
make for that they're same-length identifiers and also that they're
in the same lexicographic order.

Before-Stitch
Behind-Split

Afore-Stitch
After-Split

Among-Straddle (Among, Amidst)


So, the context then is for register state and stack contents, that
the indicators of the above as "positive presence" then is to make
for that the adjustments to the offsets and extents and the shifts
is according to those, otherwise no-ops. Then the idea is that a
"working" starts with a given context according to the expression,
then that as various of the "findings" make findings, they push either
context to act on the stack, or no-ops on the stack, then the stack
results being a fixed-size for the working according to the expression,
then the actions are always popping off a fixed amount of actions
and no-ops, with no branching, just computed "presence".



1) work starts
compute any misalignment / Start-of-Input
load word (or bytes-into-word when no-misaligned-loads)

2) word starts

(resolve startings)
(resolve endings)
(resolve stitches)

lookup/load main class
find coded
find splits
find UTF-8
find cntrl

lookup expression/grammar classes
find

(resolve splits)
(resolve straddles, byte-straddles, word-straddles)


The idea is that the predicates (properties/predicates or
code-points/range-points), are to get shifted and trimmed,
or initialized, shifted, and trimmed, so that it results the trimmings
or truncations, then have that the properties/predicates
or code-points/range-points will result matches in what results
of the initialized, shifted, and trimmed.

1) initialize (copy) the predicate/range-points
2) shift to find-start, find-continue
3) trim about the offset, extent
4) find-continue

About code-points/range-points, what's figured is that
it's always inclusive the bounds of the range, then that
the matching of a single code-point is always the matching
of two range-points that happen to be equal, so that matching
either a code-point or a range, is the same operation,
that:
not-less-than-lower && not greater-than-upper
which makes finding of range-points, also works for code-points.


So, the usual idea is that there are the various findings occurring,

find-longest-match:
shift and repeat byte-wise across the word

find-nearest-exit:

find-near:
find-far:


Then, for an expression or expressions, and grammar or grammars,
is the idea of making multi-matches, that the idea is that each of
the possibles make their exercise, and then to result after the word
is worked by each of the sub-expressions, to collate the results, or
to emit the results, then onto the next word.

Basically there is a difference among productions about whether matching
or finding is among "alternatives" or "potentials", with the idea that
matching "alternatives" is vertical while matching "potentials" is
horizontal, that a finding in terms of the NFA/DFA basically enters
either an "arc" or a "transition", that an "arc" is in the "potentials"
to make a "plant" of the "potential plant", vis-a-vis the arcs/plants
and transitions/states.

Then, an alternative has matching the first character, then whether it
introduces a potential, about that the single-character matches then
as for "double-bracket" or "triple-quote", make for that those sorts of
potentials are as according to the bracketed/quoted/escaped
expressions/grammars,
to be defining the rules of the machine.



finding potentials then is about this sort of account:

the word is N-many bytes wide

property/predicate: 1 register property, 1 register predicate -> 1
register indicators
codepoint/rangepoint: 1 register codepoint, 2 registers rangepoints -> 1
register indicators

union of findings: 2 registers indicators, 1 register indicators
intersection of findings: 2 registers indicators, 1 register indicators
setminus: ...
complement

The finding then has either a "required" or "optional" next item, when
it's in finding potentials, then across the N-many bytes, the count-down
of the initialization/shift/trim begins, then to be running down the
bytes making each match, while it continues "find-continue", or,
regardless, then that the resulting indicators look for the first
contiguous block of matches.

Then the A/B/other or likely/less-likely/un-likely, is about making the
findings, and automatically composing with making the next findings, or
as that that's in matchings, to adjust the finding as it goes along,
according to that in regular expressions it's a next match, then as with
regards to when there's backtracking and greedy/lazy or among the
greedy/possessive/... regular expressions.


The composition and decomposition of the grammars and expressions, is to
result that after EBNF and regex, the composition and decomposition,
about how to orient the productions and sub-expressions, and their
logic, toward that then alternatives and potentials are arranged their
consequences.

op: + | - | * | / | %
expr: expr op expr

( <-> )

Here the idea is that the balancing of the parentheses and their
relation to the precedence so indicated, is otherwise as according to
left-to-right and right-to-left, about then what induces the potentials
within the balanced parentheses to make expressions, about then the
evalation order of the expressions so indicated, then as with regards to
"concatenation", the most usual operation in strings,

op: /
expr: expr op expr

that when a rule mentions itself it induces a potential, and that when it
has branches that it induces alternatives.

number-initial
number: [non-zero-digit] number

identifier-body: [identifier-body-char] identifier-body
identifier: [identifier-initial] [identifier-body]

keyword: "kw1" | "kw2" | "kw3"

header:
body:
trailer:

sequences "..." introduce sequences (concatenation)
branches "|" introduce alternatives
mentions "<-" introduce potentials
options "[]" introduce options

directionality-left "<" introduces left-balancing, pairing
directionality-right ">" introduces right-balancing, pairing

The directionality or balancing/pairing is indicated when
the left-most and the right-most of the sequence so make
it indicated, the left-most and right-most of a production
of a grammar, or representation/representative of an expression.

op: /
expr: [(] expr op expr [)]

Here the expression has the left-and-right paired, and that
they're only optional mutually, i.e. both or neither, about
a sub-class of optional that's "both-or-neither".


Then, escapes introduce what is a smashing, since the idea
of escapes is that they're symbol-escapes not syntax-escapes,
vis-a-vis quoting, what itself is a syntax-escape, and comments,
what is a syntax-escape, about the escapement, and balancing
and pairing and nested escapes.

So, about the bounds and the offsets, there are the windows
(the coding regions) and the ledges (the ends of the straddles),
then for what goes on the stack of actions, and what is to result
making the stack of findings, is about the organization of

offsets
extents
bounds (offset + extent or offset, offset)

then about the window-bounds and the ledge-bounds,
in terms of those being the word-bounds, and the bounds
of the finding.


union | intersection | complement | setminus

Here complement is usually enough "not", or as
with regards to the entire space of code-points,
about where "not X " is both "universe setminus X"
and "setminus X", about expressions with universes
or "worlds of words". This is that usual accounts of language
are constructively defined as after the alphabet, that here
the alphabet is already "complete" in the sense of the range
of code-points, about then to make for where classes get
defined by ranges or indviduals the range-points, then
in terms of "not" and "complement" and "setminus",
about the logic of union and intersection.


https://wyssmann.com/blog/2019/11/extended-backus-naur-form-ebnf/
https://datatracker.ietf.org/doc/html/rfc2234 (ABNF)


ABNF in RFC2234 introduces ideas of incrementally-defined rules (3.3)
when they are alternatives, here about "composable grammars"
and the ideas of schemas of grammars.

Here there's a fundamental difference between range-points and
alternatives, since range-points are found by code-points while
alternatives would each have their own findings.

Both backtracking and balancing involve state, vis-a-vis,
the "lookahead", the "lookback", and here with regards
to "backstack", and "depthstack", or "pairstack".

The idea of "pairstack" then is each of "backstack"
and "depthstack", about that when crossing words,
while still making a finding, is that the previous words
get pushed on the backstack, then that for balancing
pairs, get pushed on the depthstack, or for example both.


A glossary develops:

register
g-register: a general-purpose register
v-register: a vector register

byte: an octet of bits, interpreted as unsigned integer or bit-flags
nybble: half a byte
word: the v-register word


character-set: a collection of elements of a language
character-encoding: content/layout/format of a character set
character: a member of a character-set
character-class: an attribute of a character or its bytes as properties
or rangepoints

input: a region in memory of contiguous character data, one or more
register words

bit-wise: operating according to index of bits
byte-wise: operating according to index of bytes

offset:
extent:
bounds:

indicators: bit-values 1 yes 0 no

properties: a byte of indicators of a categorical class
predicates: selected interest bits to indicate predicates finding
matching categorical classes
code-points: the byte or bytes that comprise a character
range-points: a lower and upper bound that defines a range of characters
inclusive or individual character

lookup-table: a 256-entry table containing properties for code-points
lookup-line: a linear-lookup cache
lookup-tree: a btree-lookup cache
lookup-file: a backing file for unboundedly many entries

expressions: components and sub-components of regular expressions
representations: examples that match expressions
grammars: rules of composition of expressions
productions: examples that match grammar rules

act: the execution of an instruction of instructions
finding, findings: act, results of making indicators of
properties/predicates or codepoints/rangepoints
matching, matchings: act, results of finding making indicating
representations, productions

made-match
mis-match

working: making findings and matchings over the input
wording: (not a word, working within a word)

straddling: when multi-byte codes cross words
splitting: working either side of a split of a straddling code
stitching: mending both sides of a split of a straddling code

smearing/unsmearing
smashing/unsmashing

backtracking
balancing

backstack
depthstack
pairstack


afore-stitch: cases of straddle, a: start of buffer, before stitch
before-split: cases of straddle, b: end of buffer, before split
after-split: cases of straddle, a: start of buffer, after split
behind-stitch: cases of straddle, b: end of buffer, after stitch



Then, the idea of that it's as a sort of dance (with steps),
or the "rhythm of work" is about the presence of cases
that maintain the context:

work-context
word-context

then about the

initialization
shifting/rotating
trimming

after the

work-offsets
word-offsets

then emitting and maintaining bounds of representatives/productions
of the expressions/grammars.


Then the idea is that for a given offset, the predicates/rangepoints
get popped off the stack, the default algorithm for predicates and
the default algorithm for rangepoints get invoked, or rather, that
a structure makes for defining "relative registers" and having both
the kinds on the same stack, then for example where when there's
potential that the passing predicate gets pushed back on the stack,
or for example that there's made round-robin of all the possible
alternatives on the stack.

Then, making a match results resetting the stack, for example
from the contents of the stack, when making multiple match.

So, in the context, there are predicates and rangepoints, these
are of various sorts.

1) a predicate/range-point is just a duplicated next-char to be spread
and then making finding, the entire word
2) a predicate/range-point is a fixed-length with an extent, to be
making finding

Among the sorts are various cases about whether there's
matching-many (repetitions) or matching-multiple (alternatives),
then for example match-1-alternative or match-all-alternatives
(multi-matching).

Then, next to the predicate/rangepoint or the definition that results
what it is, is about what matches it makes according to its findings,
the matches then being events in the representatives/productions.



Prime Rings and Prime Multisets

As an aside about an example arithmetization, there's the
idea that multisets can be embodied in an integer as primes,
with a catalog of prime numbers to members, then another
idea is about prime rings, finite rings of prime modulus.
The idea is that a given width unsigned integer can maintain
the state of a number of prime rings. For example, Z_5 the
prime ring with five elements, can be represented with 2s,
and then the multiplicity of 2's in the factorization of a number,
is the modulus of the prime ring 0-4.

2^5 = 32

Then, for example with pairs 2, 7 and 3, 5, then an integer
with range >= 7^2 * 5^3 * 3^5 * 2^7 can maintain within
it four prime rings, Z_2 Z_3 Z_5 Z_7 respectively. Then
computing the modulus (or value in the ring 0 to n-1)
is a matter of determining the multiplicity of the given
corresponding factor, while incrementing the ring is a
matter of checking whether b^n-1 is a factor, and dividing
that out to make zero in the ring, else multiplying in b,
to result incrementing in the ring Z_n. It would be usual
enough to instead make for that simply bits and multiples
of bits embody rings, then with just using increment and
modulo on them, then that to store these rings would
take 1-bit for 2, 2-bits for 3, 3-bits for 5 and 7, and so on.

Then, where that might make sense, is when for example
a state transition affects multiple prime rings, that it's a
matter of multiplying in their product to increment both
rings, vis-a-vis setting the relevant bits and adding them
in, then with regards to overflow, either in the adders as
among the bit-packed prime-rings, or in the multipliers
among the prime-backed prime-rings. Prime rings are
useful since when incrementing them each apiece, they
are not zero except when they have common factors of
the counts of increments.


Finders their Ways

So, the finders are basically working across, or down,
across in sequences, and down in alternatives. Then,
there's also that finding is either anchored as prefix-matching,
or drifting as substring-matching.

anchored: prefix-matching (from current offset)
drifting: substring-matching (across offsets)

sequence matching: fixed or likelies
alternative matching: among alternatives

Then, the idea is that the stack of work is the source of
the finders and the matchers, where the finders are the
literals that work in the standard machines, while the matchers
coordinate reaching through arcs to plants, or transitions to states,
that result representatives or productions, then what to do with those.

The standard algorithms are of these kinds:

properties/predicates:
AND the bits to result set bits meaning property = predicate
CMP-to-zero the bits to zero to result 0xFF bytes when all bits are
clear, else 0x00
NOT the bits to result 0xFF when all bits are set

PMOVMSKB the bytes to bits from v-reg to g-reg
BSF the bits to find byte-offsets where property satisfies at least one
predicate

codepoints/rangepoints
CMP-for-gte the lower bound
CMP-for-lte the upper bound
AND the comparisons meaning codepoint between rangepoints
NOT the bits to result 0xFF when all bits are set


PMOVMSKB the bytes to bits from v-reg to g-reg
BSF the bits to find byte-offsets where codepoints between rangepoints

fixed-string sub-string
XOR the bits to result clear bits meaning codepoints match
CMP-to-zero the bits to zero to result 0xFF bytes when all bits are
clear, else 0x00

PMOVMSKB the bytes to bits from v-reg to g-reg
BSF the bits to find byte-offsets where fixed-string equals substring


The predicates make unions, eg, to match either alnum or punct, about
the union of character classes.


Then, the standard algorithm must involve the union, intersection, and
complement/setminus, about expressions their usual composition. The idea
is that these form a recursive sort of account, according to implicit
and explicit precedence, that result invoking the standard
algorithms above, to result the bytes to bits from v-reg to g-reg.

These are figured to generally be "yes/no/maybe's" or "sure/yes/no's",
about making for the the union and intersection of the thing otherwise,
that are pretty simple for predicates A and B.

union A, B = A || B
intersection A, B = A && B
setminus A \ B = A && !B



So, with regards to the character-set and character-encoding, it's
figured that by default it's Unicode with UTF-8, and that source
texts are overwhelmingly printable ASCII, then that there are also
very usual files that are either UCS2 or UTF-16, or UTF-32. Then, before
the "work" function is along the lines of "detect/inspect", that
otherwise the character-set and character-encoding are assumed
invariants, then that there's as with regards to Internet messages their
declared character-set and character-encoding, and the accounts of
comments and escapes from localedef.


Then, the usual account of each word is mostly clarified, then to get
into the specific semantics of multi-byte characters (characters
generally as both printable and non-printable "characters" then as with
regards to "ligatures" generally and "escapes" generally.

The actions on multi-byte characters mostly are as with regards to
figuring their sparse (or, not completely dense) offsets their first
byte, that first there is the main class its properties, then to be
making the UTF-8 code-points into runs of bytes their characters.


So, the main-class or ascii-class properties are loaded first, instead
of first having a utf-8/non-utf-8 class, since, the distribution of the
content is overwhelmingly printable ASCII (and common control whitespace).


Then, the detection of the coded/ items that are UTF-8 encoding
items follows, with "spotting", and then about the data structures
that indicate the offsets and extents of UTF-8 encoded characters,
to then implement the "smearing", and about escape characters
that result literals, when those are "smashing".

spotting: identifying offsets and extents of UTF-8 characters,
thusly the sparseness/spotting of offsets of characters in the bytes

smearing: extending the sections of predicates according to spotting

Then, for rangepoints gets involved an example, that the ranges are
to be encoded correspondingly into ranges of the UTF-8 encoded
characters. It's figured that contiguous ranges of UTF-8 characters
have contiguous ranges of their encoded bytes.


https://en.wikipedia.org/wiki/Regular_expression
https://en.wikipedia.org/wiki/Parsing_expression_grammar
https://en.wikipedia.org/wiki/Raku_rules
https://en.wikipedia.org/wiki/Recursive_descent_parser
https://en.wikipedia.org/wiki/Thompson%27s_construction


Looking at Thompson's and Glushkov's construction for making
NFA's from expressions, then as with regards to the notion of
minimization after the outer-product or powerset making a DFA,
here is for making what actions are possible, to identify the arcs
and plants, in terms of making of those transitions and states,
about establishing the mutual interpretability of the models
of actions in prefix-matching as usual NFA's/DFA's give, with
regards to prefix- and substring- matching.

It's figured that regular language have forward recognizers,
then as with regards to backtracking and balancing, about
where the recognizer has those, that then gets into limits.

Here the idea of the predictive parser is basically for something
like where Thompson's constructive is said to guarantee that
at most two arcs exit a state, then the idea is that the predicates
can be so combinatorially enumerated, or as what so describes
the matchers, to make consecutive or plural matches in one
"operation", for plural-matches, vis-a-vis multi-matches which
is the idea of having multiple expressions of grammars, about
making plural-predictive predicates and rangepoints, off of
usual constructions of NFA's, that certain predictions are
simpler than others.

Plural Cases

literals: prefix or postfix (suffix)

A usual idea for matching literals is as about the initial-segment
and trailing segment, or, leading segment and final-segment,
where the initial-segment or final-segment is a fixed-string,
while the trailing-segment or leading-segment is variable length,
of a given class, or equivalently, when the class has range-points.
I.e., besides the notion of combining properties/predicates and
code-points/range-points, is to have the fixed-string be the
initial-segment or final-segment, and then the trailing-segment
or leading-segment is a different range in the predicate word,
then that the standard algorithm finds matches for literals
(numeric literals). It's not dissimilar for string literals, about
necessarily enough the escapement, and then also for finding forward
and finding reverse, in the word, and then checking for gaps,
retracting until checking for empty strings, for string or character
literals.

Then the idea is that any of those can be found and matched in
one "run", i.e. a stall-less, branch-less, call-less list of less than
a few or less than a few dozens or less than a few hundreds
instructions, the results "findings" in data and corresponding
"matchings" of expressions, that runs in less than one microsecond.

[toc] | [prev] | [next] | [standalone]

#124428 — You are still chewing on SIMD. LoL (Was: Viswath & Charmaigne)

Hi,

You are still chewing on SIMD. LoL

Ross Finlayson schrieb:
 > Then the idea is that any of those can be found and matched in
 > one "run", i.e. a stall-less, branch-less, call-less list of less than
 > a few or less than a few dozens or less than a few hundreds
 > instructions, the results "findings" in data and corresponding
 > "matchings" of expressions, that runs in less than one microsecond.

You cannot make the mental translation that if you have:

Ross Finlayson schrieb:
> So, the context then is for register state and stack contents, that
> the indicators of the above as "positive presence" then is to make
> for that the adjustments to the offsets and extents and the shifts
> is according to those, otherwise no-ops. Then the idea is that a

As independent logical thread state, that automatically MIMD follosw?

Whats the problem to solve then?

Bye

[toc] | [prev] | [next] | [standalone]

#124429 — Re: You are still chewing on SIMD. LoL (Was: Viswath & Charmaigne)

On 07/29/2026 08:11 AM, Mild Shock wrote:
> Hi,
>
> You are still chewing on SIMD. LoL
>
> Ross Finlayson schrieb:
>  > Then the idea is that any of those can be found and matched in
>  > one "run", i.e. a stall-less, branch-less, call-less list of less than
>  > a few or less than a few dozens or less than a few hundreds
>  > instructions, the results "findings" in data and corresponding
>  > "matchings" of expressions, that runs in less than one microsecond.
>
> You cannot make the mental translation that if you have:
>
> Ross Finlayson schrieb:
>> So, the context then is for register state and stack contents, that
>> the indicators of the above as "positive presence" then is to make
>> for that the adjustments to the offsets and extents and the shifts
>> is according to those, otherwise no-ops. Then the idea is that a
>
> As independent logical thread state, that automatically MIMD follosw?
>
> Whats the problem to solve then?
>
> Bye

MIMD-on-SIMD or MIMD-on-SIMT, alike "MOG" or something like that,
is simply enough "an interpreter" of the "embarrassingly parallel".

https://aggregate.org/MOG/

Such "embarrassingly parallel" types are subject the distinctions
of the resource models the program models the models of computation.

That's one reason it's called "embarrassingly parallel", that then
simple types with an "embarrassment of resources" can buy time.



About arithmetization and using the properties of arithmetic
to use the properties of binary logic to result reducing the
complexity of some classes of algorithms, like for example
"Polynomial approximations to some NP-hard problems", or even
using a lookup-table or free-list to make what's linear into constant
time, or loading a very wide word and using super-scalar arithmetic and
logic to reduce factorial problems by several orders of magnitude in
natural tradeoffs of time and space in terms of proximity, affinity,
coherency, and correctness, of course those are what "algorithms" are.



Speeding up naturally _serial_ algorithms here it's what's under
consideration.

It's what's for dinner.


What I'm looking at is that Thompson's still have their e's,
where Glushkov's have erased theirs, then that by building
out from those, it's deconstructed that "findings" and separated
from "matchings", then that it's not necessary to have "the state
of the state machine" in a word, instead that it's a few words on
the order of the size of the states, so that formalists can be
made happy that it's equivalent the guarantees, of correctness
and under limits, while being several times faster.

Then, of course, the idea that it naturally employs or "saturates"
the processor resources while doing work, in the low-level, yet
also has a direct interpretation in higher-level languages, even
"higher-level languages without GOTO", has also that it's faster
in both machine-organized, compiled, and interpreted environments.

Faster: and not bigger.


Not bigger.

[toc] | [prev] | [next] | [standalone]

#124434 — Re: You are still chewing on SIMD. LoL (Was: Viswath & Charmaigne)

On 29/07/2026 11:25 PM, Ross Finlayson wrote:
> On 07/29/2026 08:11 AM, Mild Shock wrote:

> 
> Then, of course, the idea that it naturally employs or "saturates"
> the processor resources while doing work, in the low-level, yet
> also has a direct interpretation in higher-level languages, even
> "higher-level languages without GOTO", has also that it's faster
> in both machine-organized, compiled, and interpreted environments.

Didn't you say in some other post you've done Java professionally?

How do you break out of a loop, from within a switch () statement
in Java?  I gather that's simply impossible, because "goto" isn't
implemented, and the "break" statement doesn't see labels outside
the switch ()?

Not sure how well that fits within comp.theory, as I haven't sub-
scribed yet, but perhaps Mild Shock is willing to comment on that
glaring deficiency in the Java programming language?

-- 
Johann | email: invalid -> com | http://www.myrkraverk.com/blog/
I'm not from the Internet, I just work there. | via Easynews.com

[toc] | [prev] | [next] | [standalone]

#124437 — Re: You are still chewing on SIMD. LoL (Was: Viswath & Charmaigne)

On 07/29/2026 08:49 AM, Johann 'Myrkraverk' Oskarsson wrote:
> On 29/07/2026 11:25 PM, Ross Finlayson wrote:
>> On 07/29/2026 08:11 AM, Mild Shock wrote:
>
>>
>> Then, of course, the idea that it naturally employs or "saturates"
>> the processor resources while doing work, in the low-level, yet
>> also has a direct interpretation in higher-level languages, even
>> "higher-level languages without GOTO", has also that it's faster
>> in both machine-organized, compiled, and interpreted environments.
>
> Didn't you say in some other post you've done Java professionally?
>
> How do you break out of a loop, from within a switch () statement
> in Java?  I gather that's simply impossible, because "goto" isn't
> implemented, and the "break" statement doesn't see labels outside
> the switch ()?
>
> Not sure how well that fits within comp.theory, as I haven't sub-
> scribed yet, but perhaps Mild Shock is willing to comment on that
> glaring deficiency in the Java programming language?
>

Well, you design the algorithm so instead of jump-tables,
the application of goto, it's just alike call/ret with
instruction jumps with call/ret, so that then the same
model in the higher-level is just plain function calls.

It's just like regular chicken, ....


Emulating GOTO in higher-level langauges, if that's the exercise, is
basically with a simple little virtual-machine-in-virtual-machine,
like an array of function pointers.


The idea here is that the jump-tables or branch-tables are simply
enough implemented without needing GOTO, yet achieving the same
result of independent re-entry alike the re-entrancy of functions,
basically modeling scope and state.

There's nothing wrong with GOTO itself, it's a great idea,
easily done wrong.

Otherwise making state-machines in higher level language usually
enough has two labels in a loop and two labels within those,
and conditions or switches in the main sort of do/while/do loop,
which is verbose and redundant and boilerplate, which of course
anybody who's implemented "state maachines" in higher-level languages
has written many times.

The jump-tables/branch-tables of course are a most usual sort
of idea of state-machines with jump (GOTO) and here call/ret
when it's not far procedures.

[toc] | [prev] | [next] | [standalone]

#124438 — I don't care about Java, pi-WAM is pi-calculus and WAM (Re: You are still chewing on SIMD. LoL)

Hi,

Using Java sometimes doesn't make me a Java
evangelist. I wouldn't care less about any
programming language, because the idea of

pi-WAM draws from pi-calculus and WAM. But
since we are in 2026, not many people
might remember pi-calculus:

Functions as Processes
Robin Milner - June 1989
https://hal.science/docs/00/07/54/05/PDF/RR-1154.pdf

AI chat bots know pi-calculus from time to
time, while interacting, they spit out
pi-calculus. I have always to tame them,

and let them cool down, since well, the
pi-calculus doesn't happen directly in the
pi-WAM. Rather in the FFI, which has create

operations on threads and queue, frankly my
pi-WAM is an extremly crippled, has only
a few primitives from pi-calculus.

BYe

Johann 'Myrkraverk' Oskarsson schrieb:
> On 29/07/2026 11:25 PM, Ross Finlayson wrote:
>> On 07/29/2026 08:11 AM, Mild Shock wrote:
> 
>>
>> Then, of course, the idea that it naturally employs or "saturates"
>> the processor resources while doing work, in the low-level, yet
>> also has a direct interpretation in higher-level languages, even
>> "higher-level languages without GOTO", has also that it's faster
>> in both machine-organized, compiled, and interpreted environments.
> 
> Didn't you say in some other post you've done Java professionally?
> 
> How do you break out of a loop, from within a switch () statement
> in Java?  I gather that's simply impossible, because "goto" isn't
> implemented, and the "break" statement doesn't see labels outside
> the switch ()?
> 
> Not sure how well that fits within comp.theory, as I haven't sub-
> scribed yet, but perhaps Mild Shock is willing to comment on that
> glaring deficiency in the Java programming language?
> 

[toc] | [prev] | [next] | [standalone]

#124439 — Underneath pi-WAM is Hack VM, you can goto (Was: I don't care about Java, pi-WAM is pi-calculus and WAM)

Hi,

pi-WAM is compiled to Hack VM. You
can realize goto's wherever you want. The
Hack VM I am using is a variant of:

The Elements of Computing Systems
Nisan, N. and Schocken, S. - June 15, 2021, MIT Press
https://mitpress.mit.edu/9780262539807/the-elements-of-computing-systems/

I just combine the 16-bit A and D instructions
into single 32-bit instructions. You
find a Hack VM interpreter for WebGPU here:

11.4 Giga Lips with a Budget Laptop
https://github.com/Jean-Luc-Picard-2021/gigabudget

Hava Fun!

Bye

Mild Shock schrieb:
> Hi,
> 
> Using Java sometimes doesn't make me a Java
> evangelist. I wouldn't care less about any
> programming language, because the idea of
> 
> pi-WAM draws from pi-calculus and WAM. But
> since we are in 2026, not many people
> might remember pi-calculus:
> 
> Functions as Processes
> Robin Milner - June 1989
> https://hal.science/docs/00/07/54/05/PDF/RR-1154.pdf
> 
> AI chat bots know pi-calculus from time to
> time, while interacting, they spit out
> pi-calculus. I have always to tame them,
> 
> and let them cool down, since well, the
> pi-calculus doesn't happen directly in the
> pi-WAM. Rather in the FFI, which has create
> 
> operations on threads and queue, frankly my
> pi-WAM is an extremly crippled, has only
> a few primitives from pi-calculus.
> 
> BYe
> 
> Johann 'Myrkraverk' Oskarsson schrieb:
>> On 29/07/2026 11:25 PM, Ross Finlayson wrote:
>>> On 07/29/2026 08:11 AM, Mild Shock wrote:
>>
>>>
>>> Then, of course, the idea that it naturally employs or "saturates"
>>> the processor resources while doing work, in the low-level, yet
>>> also has a direct interpretation in higher-level languages, even
>>> "higher-level languages without GOTO", has also that it's faster
>>> in both machine-organized, compiled, and interpreted environments.
>>
>> Didn't you say in some other post you've done Java professionally?
>>
>> How do you break out of a loop, from within a switch () statement
>> in Java?  I gather that's simply impossible, because "goto" isn't
>> implemented, and the "break" statement doesn't see labels outside
>> the switch ()?
>>
>> Not sure how well that fits within comp.theory, as I haven't sub-
>> scribed yet, but perhaps Mild Shock is willing to comment on that
>> glaring deficiency in the Java programming language?
>>
> 

[toc] | [prev] | [next] | [standalone]

#124608 — New addition to π-WAM is π-WAM Assembly (Was: Underneath pi-WAM is Hack VM, you can goto)

Hi,

 >>> How do you break out of a loop,

What Hamelt is to English language, is Hack to
Compiler Construction. The playbook of Hack contains
every drama that a Compiler Construction will face.
In the following we show how we realized Project 6:
Assembler from the Nand to Tetris journey via
a little Prolog DSL.

BTW, roughly or maybe not?
Hack (the book) =
Nand to Tetris (the website) =
Nisan, N. and Schocken, S. (the authors)

See also:

π-WAM Assembly: Comfortable Labels and Goto
https://medium.com/2989/1a11dd512813

Have Fun!

Bye


Mild Shock schrieb:
> Hi,
> 
> pi-WAM is compiled to Hack VM. You
> can realize goto's wherever you want. The
> Hack VM I am using is a variant of:
> 
> The Elements of Computing Systems
> Nisan, N. and Schocken, S. - June 15, 2021, MIT Press
> https://mitpress.mit.edu/9780262539807/the-elements-of-computing-systems/
> 
> I just combine the 16-bit A and D instructions
> into single 32-bit instructions. You
> find a Hack VM interpreter for WebGPU here:
> 
> 11.4 Giga Lips with a Budget Laptop
> https://github.com/Jean-Luc-Picard-2021/gigabudget
> 
> Hava Fun!
> 
> Bye
> 
> Mild Shock schrieb:
>> Hi,
>>
>> Using Java sometimes doesn't make me a Java
>> evangelist. I wouldn't care less about any
>> programming language, because the idea of
>>
>> pi-WAM draws from pi-calculus and WAM. But
>> since we are in 2026, not many people
>> might remember pi-calculus:
>>
>> Functions as Processes
>> Robin Milner - June 1989
>> https://hal.science/docs/00/07/54/05/PDF/RR-1154.pdf
>>
>> AI chat bots know pi-calculus from time to
>> time, while interacting, they spit out
>> pi-calculus. I have always to tame them,
>>
>> and let them cool down, since well, the
>> pi-calculus doesn't happen directly in the
>> pi-WAM. Rather in the FFI, which has create
>>
>> operations on threads and queue, frankly my
>> pi-WAM is an extremly crippled, has only
>> a few primitives from pi-calculus.
>>
>> BYe
>>
>> Johann 'Myrkraverk' Oskarsson schrieb:
>>> On 29/07/2026 11:25 PM, Ross Finlayson wrote:
>>>> On 07/29/2026 08:11 AM, Mild Shock wrote:
>>>
>>>>
>>>> Then, of course, the idea that it naturally employs or "saturates"
>>>> the processor resources while doing work, in the low-level, yet
>>>> also has a direct interpretation in higher-level languages, even
>>>> "higher-level languages without GOTO", has also that it's faster
>>>> in both machine-organized, compiled, and interpreted environments.
>>>
>>> Didn't you say in some other post you've done Java professionally?
>>>
>>> How do you break out of a loop, from within a switch () statement
>>> in Java?  I gather that's simply impossible, because "goto" isn't
>>> implemented, and the "break" statement doesn't see labels outside
>>> the switch ()?
>>>
>>> Not sure how well that fits within comp.theory, as I haven't sub-
>>> scribed yet, but perhaps Mild Shock is willing to comment on that
>>> glaring deficiency in the Java programming language?
>>>
>>
> 

[toc] | [prev] | [next] | [standalone]

#124440 — Re: I don't care about Java, pi-WAM is pi-calculus and WAM (Re: You are still chewing on SIMD. LoL)

On 07/29/2026 09:05 AM, Mild Shock wrote:
> Hi,
>
> Using Java sometimes doesn't make me a Java
> evangelist. I wouldn't care less about any
> programming language, because the idea of
>
> pi-WAM draws from pi-calculus and WAM. But
> since we are in 2026, not many people
> might remember pi-calculus:
>
> Functions as Processes
> Robin Milner - June 1989
> https://hal.science/docs/00/07/54/05/PDF/RR-1154.pdf
>
> AI chat bots know pi-calculus from time to
> time, while interacting, they spit out
> pi-calculus. I have always to tame them,
>
> and let them cool down, since well, the
> pi-calculus doesn't happen directly in the
> pi-WAM. Rather in the FFI, which has create
>
> operations on threads and queue, frankly my
> pi-WAM is an extremly crippled, has only
> a few primitives from pi-calculus.
>
> BYe
>
> Johann 'Myrkraverk' Oskarsson schrieb:
>> On 29/07/2026 11:25 PM, Ross Finlayson wrote:
>>> On 07/29/2026 08:11 AM, Mild Shock wrote:
>>
>>>
>>> Then, of course, the idea that it naturally employs or "saturates"
>>> the processor resources while doing work, in the low-level, yet
>>> also has a direct interpretation in higher-level languages, even
>>> "higher-level languages without GOTO", has also that it's faster
>>> in both machine-organized, compiled, and interpreted environments.
>>
>> Didn't you say in some other post you've done Java professionally?
>>
>> How do you break out of a loop, from within a switch () statement
>> in Java?  I gather that's simply impossible, because "goto" isn't
>> implemented, and the "break" statement doesn't see labels outside
>> the switch ()?
>>
>> Not sure how well that fits within comp.theory, as I haven't sub-
>> scribed yet, but perhaps Mild Shock is willing to comment on that
>> glaring deficiency in the Java programming language?
>>
>

Stupid gangster:  teamsters are a union.

In the trades, not the steals, ....

[toc] | [prev] | [next] | [standalone]

#124444 — A yellow mustard called Rossy Body (Was: I don't care about Java, pi-WAM is pi-calculus and WAM)

Hi,

Whats wrong with you, your face looks strange.
You look like yellow mustard called Rossy Body.

Are you yealous? Yealous that you cannot program.
Yealous that you are to stupid to cannot build
compilers. Yealous that you cannot unerstand WebGPU.

Yealous that you cannot AI Laptop. Yealous that
you have nothing to sell on usenet?

LoL

Bye

Ross Finlayson schrieb:
> Stupid gangster:  teamsters are a union.
> 
> In the trades, not the steals, ....

[toc] | [prev] | [next] | [standalone]

#124445 — Ignoramus or Ignorabimus: I don't care (π-WAM) (Was: A yellow mustard called Rossy Body)

Hi,

If any of you guys do not understand what
is meant by or what the implications are:

11.4 Giga Lips with a Budget Laptop
https://github.com/Jean-Luc-Picard-2021/gigabudget

Well I wouldn't care less. There are two
outcomes for numb nuts:

- Ignoramus: They don't understand it, but
   they will understand it before they die.

- Ignorabimus: They don't understand it, and
   will never understand it, and they die.

So who cares, its not my problem, you people
are stupid as fuck, and slow as fuck...

Bye

Mild Shock schrieb:
> Hi,
> 
> Whats wrong with you, your face looks strange.
> You look like yellow mustard called Rossy Body.
> 
> Are you yealous? Yealous that you cannot program.
> Yealous that you are to stupid to cannot build
> compilers. Yealous that you cannot unerstand WebGPU.
> 
> Yealous that you cannot AI Laptop. Yealous that
> you have nothing to sell on usenet?
> 
> LoL
> 
> Bye
> 
> Ross Finlayson schrieb:
>> Stupid gangster:  teamsters are a union.
>>
>> In the trades, not the steals, ....
> 

[toc] | [prev] | [next] | [standalone]

#124430 — Hurry Rossy Boy, the blue bus is waiting (Was: You are still chewing on SIMD. LoL)

Hi,

Hurry Rossy Boy, the blue bus is waiting.
There is a quite a hyperbole from here:

Tesla S1070 in 2008
700 Watts , 1 Terra Flop
SOLVE TOMORROW’S PROBLEMS TODAY
https://www.azken.com/download/Tesla_DS_S1070_EU.pdf

To here:

Blackwell GPU in 2026
575 Watts, 104.8 Terra Flops ( RTX 5090 )
 From Volta To Blackwell
https://newsletter.semianalysis.com/p/nvidia-tensor-core-evolution-from-volta-to-blackwell

But somehow the S1070 had already Massively-
Parallel, Many-Core Architecture, and forms
of MIMD, since it had 960 / 240 = 4 cores.

960 scalar processor cores (240 per GPU).
But possibly more resticted inside work
groups, than later NVIDIA Volta ff

architecture with independent thread state.

Bye

Disclaimer: The above is only a very rough
RTX 5090 spec. Its doesn't say what value
format and what vector/matrics ops were

used. Also energy consumption may vary.

Mild Shock schrieb:
> Hi,
> 
> You are still chewing on SIMD. LoL
> 
> Ross Finlayson schrieb:
>  > Then the idea is that any of those can be found and matched in
>  > one "run", i.e. a stall-less, branch-less, call-less list of less than
>  > a few or less than a few dozens or less than a few hundreds
>  > instructions, the results "findings" in data and corresponding
>  > "matchings" of expressions, that runs in less than one microsecond.
> 
> You cannot make the mental translation that if you have:
> 
> Ross Finlayson schrieb:
>> So, the context then is for register state and stack contents, that
>> the indicators of the above as "positive presence" then is to make
>> for that the adjustments to the offsets and extents and the shifts
>> is according to those, otherwise no-ops. Then the idea is that a
> 
> As independent logical thread state, that automatically MIMD follosw?
> 
> Whats the problem to solve then?
> 
> Bye

[toc] | [prev] | [next] | [standalone]

#124431 — Re: Hurry Rossy Boy, the blue bus is waiting (Was: You are still chewing on SIMD. LoL)

On 07/29/2026 08:32 AM, Mild Shock wrote:
> Hi,
>
> Hurry Rossy Boy, the blue bus is waiting.
> There is a quite a hyperbole from here:
>
> Tesla S1070 in 2008
> 700 Watts , 1 Terra Flop
> SOLVE TOMORROW’S PROBLEMS TODAY
> https://www.azken.com/download/Tesla_DS_S1070_EU.pdf
>
> To here:
>
> Blackwell GPU in 2026
> 575 Watts, 104.8 Terra Flops ( RTX 5090 )
>  From Volta To Blackwell
> https://newsletter.semianalysis.com/p/nvidia-tensor-core-evolution-from-volta-to-blackwell
>
>
> But somehow the S1070 had already Massively-
> Parallel, Many-Core Architecture, and forms
> of MIMD, since it had 960 / 240 = 4 cores.
>
> 960 scalar processor cores (240 per GPU).
> But possibly more resticted inside work
> groups, than later NVIDIA Volta ff
>
> architecture with independent thread state.
>
> Bye
>
> Disclaimer: The above is only a very rough
> RTX 5090 spec. Its doesn't say what value
> format and what vector/matrics ops were
>
> used. Also energy consumption may vary.
>
> Mild Shock schrieb:
>> Hi,
>>
>> You are still chewing on SIMD. LoL
>>
>> Ross Finlayson schrieb:
>>  > Then the idea is that any of those can be found and matched in
>>  > one "run", i.e. a stall-less, branch-less, call-less list of less than
>>  > a few or less than a few dozens or less than a few hundreds
>>  > instructions, the results "findings" in data and corresponding
>>  > "matchings" of expressions, that runs in less than one microsecond.
>>
>> You cannot make the mental translation that if you have:
>>
>> Ross Finlayson schrieb:
>>> So, the context then is for register state and stack contents, that
>>> the indicators of the above as "positive presence" then is to make
>>> for that the adjustments to the offsets and extents and the shifts
>>> is according to those, otherwise no-ops. Then the idea is that a
>>
>> As independent logical thread state, that automatically MIMD follosw?
>>
>> Whats the problem to solve then?
>>
>> Bye
>

Herf the Earth

[toc] | [prev] | [next] | [standalone]

Page 1 of 6  [1] 2 3 4 5 6  Next page →

Back to top | Article view | comp.lang.c++

csiph-web