Path: ...!Xl.tags.giganews.com!local-2.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 25 Apr 2024 17:46:40 +0000
Subject: Re: Meta: a usenet server just for sci.math
Newsgroups: sci.math,news.software.nntp,comp.programming.threads
References: <8f7c0783-39dd-4f48-99bf-f1cf53b17dd9@googlegroups.com>
 <b0c4589a-f222-457e-95b3-437c0721c2a2n@googlegroups.com>
 <5a48e832-3573-4c33-b9cb-d112f01b733bn@googlegroups.com>
 <8wWdnVqZk54j3Fj4nZ2dnZfqnPGdnZ2d@giganews.com>
 <MY-cnRuWkPoIhFr4nZ2dnZfqnPSdnZ2d@giganews.com>
 <NqqdnbEz-KTJTlr4nZ2dnZfqnPudnZ2d@giganews.com>
 <FqOcnYWdRfEI2lT4nZ2dnZfqn_SdnZ2d@giganews.com>
 <NVudnVAqkJ0Sk1D4nZ2dnZfqn_idnZ2d@giganews.com>
 <RuKdnfj4NM2rlkz4nZ2dnZfqn_qdnZ2d@giganews.com>
 <HfCdnROSvfir-E_4nZ2dnZfqnPWdnZ2d@giganews.com>
 <FLicnRkOg7SrWU_4nZ2dnZfqnPadnZ2d@giganews.com>
 <v7ecnUsYY7bW40j4nZ2dnZfqnPudnZ2d@giganews.com>
 <q7-dnR2O9OsAAH74nZ2dnZfqnPhg4p2d@giganews.com>
 <Hp-cnUAirtFtx2P4nZ2dnZfqnPednZ2d@giganews.com>
 <MDKdnRJpQ_Q87Z77nZ2dnZfqn_idnZ2d@giganews.com>
 <-bOdnWSSIMUKcZn7nZ2dnZfqnPednZ2d@giganews.com>
 <CoCdnYJuP9p8aob7nZ2dnZfqnPudnZ2d@giganews.com>
 <bJ6dna6Zv4r7lbn7nZ2dnZfqn_WdnZ2d@giganews.com>
 <TO6cnaz7jdFtBbv7nZ2dnZfqn_WdnZ2d@giganews.com>
From: Ross Finlayson <ross.a.finlayson@gmail.com>
Date: Thu, 25 Apr 2024 10:46:48 -0700
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:38.0) Gecko/20100101
 Thunderbird/38.6.0
MIME-Version: 1.0
In-Reply-To: <TO6cnaz7jdFtBbv7nZ2dnZfqn_WdnZ2d@giganews.com>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <5hednQYuTYucCrf7nZ2dnZfqnPcAAAAA@giganews.com>
Lines: 1154
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Ph1782X8OgeKhsuagHa/SnmGDu/uy0m3hDR7Ig/zyRim1yKvTr684LHp5utdxzQIU28kDhZS8Wttbzq!BzNHOjtEr3Oudyy4wXytoGdDLvhYnOpfOWFr6egPDQiQir3bph96p1dZlkV53EXno/I0YM0E0aY=
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
Bytes: 55467

On 04/22/2024 10:06 AM, Ross Finlayson wrote:
> On 04/20/2024 11:24 AM, Ross Finlayson wrote:
>>
>>
>> Well I've been thinking about the re-routine as a model of cooperative
>> multithreading,
>> then thinking about the flow-machine of protocols
>>
>> NNTP
>> IMAP <-> NNTP
>> HTTP <-> IMAP <-> NNTP
>>
>> Both IMAP and NNTP are session-oriented on the connection, while,
>> HTTP, in terms of session, has various approaches in terms of HTTP 1.1
>> and connections, and the session ID shared client/server.
>>
>>
>> The re-routine idea is this, that each kind of method, is memoizable,
>> and, it memoizes, by object identity as the key, for the method, all
>> its callers, how this is like so.
>>
>> interface Reroutine1 {
>>
>> Result1 rr1(String a1) {
>>
>>      Result2 r2 = reroutine2.rr2(a1);
>>
>>      Result3 r3 = reroutine3.rr3(r2);
>>
>>      return result(r2, r3);
>> }
>>
>> }
>>
>>
>> The idea is that the executor, when it's submitted a reroutine,
>> when it runs the re-routine, in a thread, then it puts in a ThreadLocal,
>> the re-routine, so that when a re-routine it calls, returns null as it
>> starts an asynchronous computation for the input, then when
>> it completes, it submits to the executor the re-routine again.
>>
>> Then rr1 runs through again, retrieving r2 which is memoized,
>> invokes rr3, which throws, after queuing to memoize and
>> resubmit rr1, when that calls back to resubmit r1, then rr1
>> routines, signaling the original invoker.
>>
>> Then it seems each re-routine basically has an instance part
>> and a memoized part, and that it's to flush the memo
>> after it finishes, in terms of memoizing the inputs.
>>
>>
>> Result 1 rr(String a1) {
>>    // if a1 is in the memo, return for it
>>    // else queue for it and carry on
>>
>> }
>>
>>
>> What is a re-routine?
>>
>>      It's a pattern for cooperative multithreading.
>>
>>      It's sort of a functional approach to functions and flow.
>>
>>      It has a declarative syntax in the language with usual
>> flow-of-control.
>>
>> So, it's cooperative multithreading so it yields?
>>
>>      No, it just quits, and expects to be called back.
>>
>> So, if it quits, how does it complete?
>>
>>      The entry point to re-routine provides a callback.
>>
>>      Re-routines only return results to other re-routines,
>>      It's the default callback.  Otherwise they just callback.
>>
>> So, it just quits?
>>
>>      If a re-routine gets called with a null, it throws.
>>
>>      If a re-routine gets a null, it just continues.
>>
>>      If a re-routine completes, it callbacks.
>>
>> So, can a re-routine call any regular code?
>>
>>      Yeah, there are some issues, though.
>>
>> So, it's got callbacks everywhere?
>>
>>      Well, it's just got callbacks implicitly everywhere.
>>
>> So, how does it work?
>>
>>      Well, you build a re-routine with an input and a callback,
>>      you call it, then when it completes, it calls the callback.
>>
>>      Then, re-routines call other re-routines with the argument,
>>      and the callback's in a ThreadLocal, and the re-routine memoizes
>>      all of its return values according to the object identity of the
>> inputs,
>>      then when a re-routine completes, it calls again with another
>> ThreadLocal
>>      indicating to delete the memos, following the exact same
>> flow-of-control
>>      only deleting the memos going along, until it results all the
>> memos in
>>      the re-routines for the interned or ref-counted input are deleted,
>>      then the state of the re-routine is de-allocated.
>>
>> So, it's sort of like a monad and all in pure and idempotent functions?
>>
>>      Yeah, it's sort of like a monad and all in pure and idempotent
>> functions.
>>
>> So, it's a model of cooperative multithreading, though with no yield,
>> and callbacks implicitly everywhere?
>>
>>      Yeah, it's sort of figured that a called re-routine always has a
>> callback in the ThreadLocal, because the runtime has pre-emptive
>> multithreading anyways, that the thread runs through its re-routines in
>> their normal declarative flow-of-control with exception handling, and
>> whatever re-routines or other pure monadic idempotent functions it
>> calls, throw when they get null inputs.
>>
>>      Also it sort of doesn't have primitive types, Strings must always
>> be interned, all objects must have a distinct identity w.r.t. ==, and
>> null is never an argument or return value.
>>
>> So, what does it look like?
>>
>> interface Reroutine1 {
>>
>> Result1 rr1(String a1) {
>>
>>      Result2 r2 = reroutine2.rr2(a1);
>>
>>      Result3 r3 = reroutine3.rr3(r2);
>>
>>      return result(r2, r3);
>> }
>>
>> }
>>
>> So, I expect that to return "result(r2, r3)".
>>
>>      Well, that's synchronous, and maybe blocking, the idea is that it
>> calls rr2, gets a1, and rr2 constructs with the callback of rr1 and it's
>> own callback, and a1, and makes a memo for a1, and invokes whatever is
>> its implementation, and returns null, then rr1 continues and invokes rr3
>> with r2, which is null, so that throws a NullPointerException, and rr1
>> quits.
>>
>> So, ..., that's cooperative multithreading?
>>
>>      Well you see what happens is that rr2 invoked another re-routine or
========== REMAINDER OF ARTICLE TRUNCATED ==========