2025-03-11 - libera.chat:#esolangs

00:13:35 <sprout> your compiler might use a random generator in some heuristical optimization, and the cpu might have a branch predictor which -despite it's name- gives unpredictable behavior

00:17:25 <zzo38> Timing would still be possible, if the program is given a capability that can be triggered according to the amount of time that has passed (all I/O would be using capabilities, in this system). That is how I would have any programs dealing with time to work. (This is a bit like timerfd_create, but it is not a system call; you need to be given the capability when starting the program or from another capability.)

00:42:07 -!- amby has quit (Quit: so long suckers! i rev up my motorcylce and create a huge cloud of smoke. when the cloud dissipates im lying completely dead on the pavement).

00:42:45 <korvo> Timing requirements don't ruin the Galois theory, I think. Instead of just talking about functions, we'd talk about functions equipped with some writing monad.

00:50:40 <esolangs> [[User:Hotcrystal0/Deep]] https://esolangs.org/w/index.php?diff=153683&oldid=153678 * Hotcrystal0 * (+76)

01:11:59 <esolangs> [[Talk:.exe]] N https://esolangs.org/w/index.php?oldid=153684 * Baldibacak * (+146) /* minecraft is not written in .exe */ new section

01:45:10 <esolangs> [[User:Zip]] https://esolangs.org/w/index.php?diff=153685&oldid=103764 * Zip * (+139)

01:49:07 <esolangs> [[User:Zip/Thue/CT]] N https://esolangs.org/w/index.php?oldid=153686 * Zip * (+1073) Created page with "[[Bitwise Cyclic Tag#The_language_CT|CT]] interpreter in Thue. '''NOTE:''' Assumes that lines before the final <code>::=</code> that don't contain <code>::=</code> are comments. This is the behavior of Delic's Thue interpreter, but probably most interpreters don't

02:09:18 <esolangs> [[User:I am islptng/List of the users that is also in conwaylife.com]] https://esolangs.org/w/index.php?diff=153687&oldid=152249 * Hotcrystal0 * (+34)

02:58:45 <esolangs> [[User talk:Stkptr]] https://esolangs.org/w/index.php?diff=153688&oldid=153472 * I am islptng * (+593)

03:01:13 <esolangs> [[User talk:Hotcrystal0/Deep]] N https://esolangs.org/w/index.php?oldid=153689 * I am islptng * (+563) Created page with "I hope it'll be Turing-Complete. --~~~~"

03:05:55 <esolangs> [[User:I am islptng/Draft for Esolang]] N https://esolangs.org/w/index.php?oldid=153690 * I am islptng * (+51) Created page with "Esolang is a language designed by islptng."

04:29:34 <esolangs> [[StackBBQ2]] N https://esolangs.org/w/index.php?oldid=153691 * I am islptng * (+748) Created page with "StackBBQ2 is a computation model / esolang created by islptng. It has a stack that holds bits, a queue Q that holds bits, and a stack P that holds queues. == Instructions == <code>1</code> push True to stack. <code>0</code> pops a, pops b, and pops c if !(a&

04:36:42 <esolangs> [[StackBBQ2]] https://esolangs.org/w/index.php?diff=153692&oldid=153691 * I am islptng * (-98)

04:42:28 <esolangs> [[StackBBQ2]] https://esolangs.org/w/index.php?diff=153693&oldid=153692 * I am islptng * (-33)

04:47:08 <esolangs> [[StackBBQ2]] https://esolangs.org/w/index.php?diff=153694&oldid=153693 * I am islptng * (+793)

04:52:53 <esolangs> [[StackBBQ2]] https://esolangs.org/w/index.php?diff=153695&oldid=153694 * I am islptng * (-124) /* Interpreter */

04:57:15 <esolangs> [[3]] https://esolangs.org/w/index.php?diff=153696&oldid=147633 * I am islptng * (+1) "ZCX" -> "I am"

05:02:38 <esolangs> [[User talk:Stkptr]] https://esolangs.org/w/index.php?diff=153697&oldid=153688 * Stkptr * (+944)

05:06:19 <zzo38> Also, some versions of UNIX philosophy specify to use text, but I would instead use a type-length-value format, somewhat like DER, although there are some differences, including what types are available, as well as other differences.

05:09:47 <zzo38> UNIX philosophy also intend every program should be made as a filter, and in this case it should also intend, and the TLV format can be used. (The operating system does not enforce to use the TLV format, but it should be expected, that the included software, and other software designed for it, should use it. However, it does enforce that all I/O can be filtered.)

05:13:33 <zzo38> (There are three character string types: ASCII string, TRON string, and string of 8-bit characters of a specified character set (of which ASCII is a special case, which is common enough to be given its own code; ASCII also has a special case having to do with keyboard handling in command mode (rather than other modes such as text entry mode)).)

05:15:43 <zzo38> I did make a list of what some of the data types will be. In addition to those ones, there is also the common stuff such as integer, sequence, key/value list, boolean, null, etc; but also such things as: text document, diagram, time series, tagged data, calculation, etc.

05:31:54 <esolangs> [[User:Stkptr]] https://esolangs.org/w/index.php?diff=153698&oldid=126825 * Stkptr * (+1107)

05:45:01 <esolangs> [[User talk:Stkptr]] https://esolangs.org/w/index.php?diff=153699&oldid=153697 * I am islptng * (+16) /* StackBBQ */

06:00:21 <esolangs> [[Piet-Q]] https://esolangs.org/w/index.php?diff=153700&oldid=74480 * Stkptr * (-12)

06:09:12 <zzo38> (I would also have many other differences. Such as, application programs can request what character set is wanted for text input, as well as other keyboard modes. Another will be locales working. Some things do not belong in the locale setting and belong in a different setting instead, and some things do belong but should be made differently than other systems are doing.)

06:29:21 <esolangs> [[ParScript]] https://esolangs.org/w/index.php?diff=153701&oldid=140505 * Stkptr * (+100) /* Turing-completeness */

06:31:11 <esolangs> [[Spleenmap]] https://esolangs.org/w/index.php?diff=153702&oldid=39734 * Stkptr * (-6) FSM

06:35:52 <esolangs> [[User:I am islptng/List of "x bits, y bytes"]] https://esolangs.org/w/index.php?diff=153703&oldid=151641 * I am islptng * (+36)

06:42:30 <esolangs> [[2 digits, 50 digytes]] N https://esolangs.org/w/index.php?oldid=153704 * I am islptng * (+514) Created page with "This language has 99 5-digit number memory, numbered 00-98. (99 is used for I/O.) Instruction set: 0 let f t: f = t 1 add f t: f += t 2 sub f t: f -= t 3 mul f t: f *= t (mod 105) 4 div f t: f /= t 5 mod f t: f %= t 6 ant f t: f &= ~t

06:44:26 <esolangs> [[User:I am islptng]] https://esolangs.org/w/index.php?diff=153705&oldid=153491 * I am islptng * (+71) /* My esolangs */

06:44:47 <esolangs> [[User:I am islptng]] https://esolangs.org/w/index.php?diff=153706&oldid=153705 * I am islptng * (+27)

07:32:17 <esolangs> [[User:C0ffee]] https://esolangs.org/w/index.php?diff=153707&oldid=152616 * C0ffee * (+11)

07:33:59 <esolangs> [[User:C0ffee]] https://esolangs.org/w/index.php?diff=153708&oldid=153707 * C0ffee * (+14)

07:34:30 <esolangs> [[User:C0ffee]] https://esolangs.org/w/index.php?diff=153709&oldid=153708 * C0ffee * (-16)

07:34:44 <esolangs> [[User:C0ffee]] https://esolangs.org/w/index.php?diff=153710&oldid=153709 * C0ffee * (+6)

07:36:11 <esolangs> [[User:C0ffee]] https://esolangs.org/w/index.php?diff=153711&oldid=153710 * C0ffee * (-2)

08:29:00 <esolangs> [[Targs]] https://esolangs.org/w/index.php?diff=153712&oldid=124719 * Stkptr * (+11) no loops

10:43:19 <ais523> <b_jonas> zzo38: last time I looked, I had the impression that CPUs are built such that it's hard to eliminate all the non-determinacy from programs that deliberately try to be non-deterministic by doing weird things, and I think the only way around that would be some kind of overkill like a whole virtual machine. but I could be wrong. ← most of that sort of nondeterminism is only observable using either a) race conditions, b) observation of timing, or c)

10:44:01 <ais523> a) and b) can mostly be eliminated by locking programs to a single thread at a time, and giving them no access to any timing sources

10:44:49 <ais523> it's easy enough to enforce determinism in programs if you compile them from some other language rather than just running arbitrary machine code, though

10:50:12 <b_jonas> yes, plus there's a lot of timing inefficiency, so you have to be prepared to wait a LOT for a program that happens to run slower than expected so that the timeout can't be detected

11:30:54 <esolangs> [[User:Hotcrystal0/Deep]] https://esolangs.org/w/index.php?diff=153713&oldid=153683 * Hotcrystal0 * (+444)

12:18:37 <esolangs> [[User:Hotcrystal0/Deep]] https://esolangs.org/w/index.php?diff=153714&oldid=153713 * Hotcrystal0 * (+116)

12:19:08 <esolangs> [[User:Hotcrystal0/Deep]] https://esolangs.org/w/index.php?diff=153715&oldid=153714 * Hotcrystal0 * (+0)

12:19:23 <esolangs> [[User:Hotcrystal0/Deep]] https://esolangs.org/w/index.php?diff=153716&oldid=153715 * Hotcrystal0 * (-75)

12:19:43 <esolangs> [[User talk:Hotcrystal0/Deep]] https://esolangs.org/w/index.php?diff=153717&oldid=153689 * Hotcrystal0 * (+135)

12:24:53 <esolangs> [[User:Hotcrystal0/Deep]] https://esolangs.org/w/index.php?diff=153718&oldid=153716 * Hotcrystal0 * (+226)

12:50:10 <ais523> b_jonas: actually the "I only want to run code that's been compiled with a trusted compiler" problem is one that I will probably have to end up solving at some point

12:50:45 <ais523> you would need the compiler to somehow sign that the code had been compiled correctly, but it's not obvious how you would prevent incorrectly code being signed the same way

12:51:51 <ais523> I guess the solutions involve either a) some sort of central compile-and-sign authority which everyone trusts (Apple is moving in that direction, although I don't think they're there yet), or b) every computer has its own set of signing keys, and does a compile-and-sign with its own keys, and those keys aren't readable by anything but the compiler (e.g. because you don't run code without first proving that it cannot read them)

12:55:48 <ais523> oh, you could also have a list somewhere of hashes of code that was known to have been compiled correctly, that's probably a better option

12:56:21 <ais523> i.e. you build it yourself and then add the hash of the resulting code to the list of code that's known to be OK – that doesn't require blocking read access to the list to untrusted programs, just write access

12:57:00 <b_jonas> ais523: yes, I think java and webassembly are kind of trying to work that way, with a slower compiler emitting an intermediate representation that can be verified and compiled on the machine that will run it. but deterministic execution is harder than just that. I was thinking a bit about that for multiplayer games where one machine can send untrusted code that other machines have to run as well, and

12:57:06 <b_jonas> you want the code to run deterministically on multiple machines so that the game state stays synced among machines.

13:03:49 <b_jonas> there's also multiple grades of deterministic execution, eg. (a) do you want to allow remote side effects within an execution environment eg. because the program can read the address of allocations, which are the same everywhere becuase you're using the same deterministic allocator, but can depend on what unrelated parts of the code do, (b) do you want stability among different versions of the compiler

13:03:55 <b_jonas> or runtime so if you upgrade the result of the execution doesn't change, or even everything specified so deterministically that a clean reimplementation from the spec can result in the same execution, (c) do you want the same results on different underlying hardware, especially CPU architecture, (d) do you want to forbid timeouts, guarantee that if the code doesn't time out on one machine then you can

13:05:33 <ais523> I guess you also have to make decisions like "make allocation addresses deterministic" versus "make the program unable to act differently based on allocation addresses"

13:07:27 <ais523> something I have been thinking about for a while is that it might be more efficient for programs to control their own memory map

13:07:33 <b_jonas> ais523: yes, the latter you do by allowing the user to declare user-defined types that have a nominal address, which you just assign sequentially using a global counter, regardless of the actual address

13:07:44 <ais523> i.e. it's the program rather than the OS that decides where in virtual memory to allocate the allocations

13:08:28 <ais523> e.g. you could tell what allocator allocated an object just by looking at a particular part of the address

13:08:49 <ais523> (that said, I don't know much about the performance of weirdly placed memory mappings)

13:09:16 <b_jonas> and even sorting if you allow the user to define custom comparison functions

13:09:49 <ais523> oh, I see, the problem is not so much making it determinstic as defining what the deterministic behaviour is

13:10:59 <ais523> for sorting, I think it is sufficient to a) make the sort stable and b) force the comparison function to be entirely pure, i.e. it cannot affect the program in any way other than its return value

13:11:08 <b_jonas> the OS assigning addresses isn't really a problem unless you want to make a very efficient compiled program, I just want a less efficient interpreter so there the actual absolute address won't matter, only the relative address within the small number of memory pools into which I address relatively with an index

13:12:19 <ais523> I think forcing the address might be a simpler solution anyway than having a separate, parallel address scheme – although it would depend on what program you were running, most likely

13:12:46 <b_jonas> but if you want to control the actual address, you are already allowed to do that, but of course then you may need some architecture-dependent code because not all addresses may be allowed

13:12:52 <ais523> the main disadvantage of forcing the address is that you don't get ASLR, although I guess in a deterministic execution scheme ASLR wouldn't matter as it couldn't have any effect on the program anyway

13:13:10 <ais523> yes, it is possible to control the address even on modern computers, just people don't normally bother

13:13:25 <ais523> my plans for that are along the lines of "keep the kernel the same but replace the dynamic loader"

13:14:00 <b_jonas> ais523: I don't think even ASLR would be incompatible, as long as you don't let the untrusted program get a pointer to anything that's randomized, only to areas that you allocate, and you divide the address space to areas that the randomization can use and ones to where you allocate in advance

13:14:29 <b_jonas> I just think you could run into problems on an alien architecture where eg. all your pointers are negative, if on normal architectures all your pointers are positive, or something like that

13:15:07 <ais523> b_jonas: oh, my plans involved the compiler taking advantage of this but the source code not taking advantage of it, so it can easily be architecture-specific

13:16:35 <ais523> it doesn't – but my plan would involve not randomizing some of the middle bits

13:16:45 <ais523> and that doesn't seem conceptually different from not randomizing the low bits

13:20:19 <b_jonas> I mean, if ASLR doesn't randomize the high bits so eg. your runtime is loaded above 0x00004000_00000000 and you allocate the untrusted program's data below 0x00004000_00000000 then you have no conflicts; but if ASLR doesn't randomize the low bits so it always loads at a 16k boundary that won't help you because you want continuous chunks so you can't just use memory that's not 16k aligned for the

13:21:13 <ais523> right, tagging bits should ideally be as high as possible (while staying within virtual address space) so that you have more contiguous memory if you need it – although I fear that might make the page tables less efficient

13:22:04 <b_jonas> what? no, tagging bits should be low because you'll only have pointers to aligned data anyway

13:22:30 <ais523> I mean, "free" tagging bits that you get by actually allocating the memory there, rather than masking them off

13:24:25 <b_jonas> I haven't thought much about these actual addresses because I'm mostly thinking of a not too optimized interpreter implementation

13:25:25 <b_jonas> so I wouldn't handle native pointers, but like indexes into a small fixed number of arenas that the interpreter can allocate anywhere

13:25:58 <ais523> I'm basically thinking of a similar system except where the arenas have fixed addresses

13:26:15 <b_jonas> that would also add to memory safety because even if I mess up and have a corrupted pointer data it will point into valid memory of the simulated program

13:26:52 <b_jonas> (there may be multiple types of pointers that point to different sets of arenas, but that's fine)

13:27:17 <ais523> oh, I see, the reason it increases safety is that it is necessarily pointing to data rather than, say, a return address on the stack

13:27:33 <ais523> and because you are protected from wild pointers already, it doesn't matter if you corrupt a pointer value

13:28:18 <ais523> I have been considering a scheme where allocations are power-of-2 size and array indexing is masked to wrap around the array – that would gain memory safety in a similar manner (and as a bonus fixes one of the variants of Spectre)

13:29:42 <b_jonas> and what I really want is that some of the arenas are just mapped read-only fixed data that's created when I compile the interpreter, so that there's little overload for spinning up new interpreter instances, even if they load a lot of built-in objects, to avoid the stereotypical 90s problem where a tiny little Java program needs to consume hundreds of megabytes to load some libraries. or ideally it's

13:29:48 <b_jonas> not even separate arenas, but just a read-only section mapped over the start of the normal arena, so that half of the code doesn't even have to distinguish the read-only and read-write section

13:30:17 <ais523> one of the motivations for my "free tagging" scheme in the first place was so that you could have string pointers that could point to either heap data or static data, and deallocate them only if they were on the heap

13:30:44 <ais523> I guess you can do that even without free-tagging – it's possible to check where the static data is and/or where the heap is – but there might be some overhead in storing the location

13:33:25 <b_jonas> and this kind of memory safety can be used either alone, which is useful if you want a C interpreter that can run existing C code, since type safety can't be guaranteed there; or you can use it together with a type system and memory safety system that guarantees that all pointers are valid, as another line of defense

14:00:06 <esolangs> [[Esolang:Introduce yourself]] https://esolangs.org/w/index.php?diff=153719&oldid=153632 * Huywallz * (+188) /* Introductions */

14:20:17 <esolangs> [[Stillbrithiarngialpielroinuslislislislislisquattostamiswackilduasliesfris]] N https://esolangs.org/w/index.php?oldid=153720 * PrySigneToFry * (+4416) Created page with "Stillbrithiarngialpielroinuslislislislislisquattostamiswackilduasliesfris (or Stilbrith if you can't pronounce this, or even Stilllbrillbritillbrithithiarithiarngiarngiarngialbrithiarngialpialpielpi

14:20:35 <esolangs> [[Stillbrithiarngialpielroinuslislislislislisquattostamiswackilduasliesfris]] https://esolangs.org/w/index.php?diff=153721&oldid=153720 * PrySigneToFry * (+1)

14:23:31 <esolangs> [[User:PrySigneToFry/Sandbox]] https://esolangs.org/w/index.php?diff=153722&oldid=152928 * PrySigneToFry * (+100)

14:26:35 <esolangs> [[Talk:Albuquerque challenge]] https://esolangs.org/w/index.php?diff=153723&oldid=151708 * PrySigneToFry * (+2351)

14:28:26 <esolangs> [[UserEdited/Versions]] https://esolangs.org/w/index.php?diff=153724&oldid=153381 * Hotcrystal0 * (+36)

14:28:56 <esolangs> [[UserEdited]] https://esolangs.org/w/index.php?diff=153725&oldid=153382 * Hotcrystal0 * (-7)

14:29:07 <esolangs> [[UserEdited/Versions]] https://esolangs.org/w/index.php?diff=153726&oldid=153724 * Hotcrystal0 * (-4)

14:31:04 <esolangs> [[UserEdited]] https://esolangs.org/w/index.php?diff=153727&oldid=153725 * Hotcrystal0 * (+338)

14:38:49 <esolangs> [[UserEdited]] https://esolangs.org/w/index.php?diff=153728&oldid=153727 * Hotcrystal0 * (-1) fixed Arabian -> Arabic

14:45:57 <esolangs> [[User:Hotcrystal0/Deep]] https://esolangs.org/w/index.php?diff=153729&oldid=153718 * Hotcrystal0 * (+92)

14:46:42 <esolangs> [[User:Hotcrystal0/Deep]] https://esolangs.org/w/index.php?diff=153730&oldid=153729 * Hotcrystal0 * (+20)

14:47:14 <esolangs> [[User:Hotcrystal0/Deep]] https://esolangs.org/w/index.php?diff=153731&oldid=153730 * Hotcrystal0 * (+2)

14:47:41 <esolangs> [[User:Hotcrystal0/Deep]] https://esolangs.org/w/index.php?diff=153732&oldid=153731 * Hotcrystal0 * (+42)

14:48:01 <esolangs> [[User:Hotcrystal0/Deep]] https://esolangs.org/w/index.php?diff=153733&oldid=153732 * Hotcrystal0 * (+12)

14:48:09 <esolangs> [[User:Hotcrystal0/Deep]] https://esolangs.org/w/index.php?diff=153734&oldid=153733 * Hotcrystal0 * (+1)

14:48:22 <esolangs> [[User:Hotcrystal0/Deep]] https://esolangs.org/w/index.php?diff=153735&oldid=153734 * Hotcrystal0 * (+18)

14:53:21 <esolangs> [[User:Hotcrystal0/Deep]] https://esolangs.org/w/index.php?diff=153736&oldid=153735 * Hotcrystal0 * (+138)

15:01:47 <esolangs> [[Stillbrithiarngialpielroinuslislislislislisquattostamiswackilduasliesfris]] https://esolangs.org/w/index.php?diff=153737&oldid=153721 * Hotcrystal0 * (+4)

15:02:19 <esolangs> [[Stillbrithiarngialpielroinuslislislislislisquattostamiswackilduasliesfris]] https://esolangs.org/w/index.php?diff=153738&oldid=153737 * Hotcrystal0 * (+8)

15:02:30 <esolangs> [[Stillbrithiarngialpielroinuslislislislislisquattostamiswackilduasliesfris]] https://esolangs.org/w/index.php?diff=153739&oldid=153738 * Hotcrystal0 * (+6)

15:06:18 <esolangs> [[User:Hotcrystal0/User chart]] https://esolangs.org/w/index.php?diff=153740&oldid=151992 * Hotcrystal0 * (+250)

15:07:23 <esolangs> [[User:Hotcrystal0/List of users who are also on the TBG forums]] N https://esolangs.org/w/index.php?oldid=153741 * Hotcrystal0 * (+71) Created page with "islptng made one for conwaylife.com, so why not the TBG forums as well?"

15:09:07 <esolangs> [[User:Hotcrystal0/List of users who are also on the TBG forums]] https://esolangs.org/w/index.php?diff=153742&oldid=153741 * Hotcrystal0 * (+232)

15:09:18 <esolangs> [[User:Hotcrystal0/List of users who are also on the TBG forums]] https://esolangs.org/w/index.php?diff=153743&oldid=153742 * Hotcrystal0 * (+10)

15:09:42 <esolangs> [[User:Hotcrystal0/List of users who are also on the TBG forums]] https://esolangs.org/w/index.php?diff=153744&oldid=153743 * Hotcrystal0 * (+0)

15:12:18 <esolangs> [[User:Hotcrystal0]] https://esolangs.org/w/index.php?diff=153745&oldid=153669 * Hotcrystal0 * (+130)

15:12:28 <esolangs> [[User:Hotcrystal0]] https://esolangs.org/w/index.php?diff=153746&oldid=153745 * Hotcrystal0 * (-1) Typo fix

15:12:56 <esolangs> [[User:I am islptng/List of the users that is also in conwaylife.com]] https://esolangs.org/w/index.php?diff=153747&oldid=153687 * Hotcrystal0 * (+0) capitalization fix

15:13:49 <esolangs> [[User talk:Gilbert189]] https://esolangs.org/w/index.php?diff=153748&oldid=140294 * Hotcrystal0 * (+237)

15:17:09 <esolangs> [[User:Hotcrystal0/Sandbox]] https://esolangs.org/w/index.php?diff=153749&oldid=153445 * Hotcrystal0 * (+98)

15:20:41 <esolangs> [[User talk:PkmnQ]] https://esolangs.org/w/index.php?diff=153750&oldid=153676 * Hotcrystal0 * (+117)

15:20:56 <esolangs> [[User talk:PkmnQ]] https://esolangs.org/w/index.php?diff=153751&oldid=153750 * Hotcrystal0 * (+93) forgot signature

15:24:12 <esolangs> [[User:Hotcrystal0/List of users who are also on the TBG forums]] https://esolangs.org/w/index.php?diff=153752&oldid=153744 * Hotcrystal0 * (+45)

15:25:38 <esolangs> [[User:Hotcrystal0/User chart]] https://esolangs.org/w/index.php?diff=153753&oldid=153740 * Hotcrystal0 * (+10)

15:26:06 <esolangs> [[User:Hotcrystal0/User chart]] https://esolangs.org/w/index.php?diff=153754&oldid=153753 * Hotcrystal0 * (-315) Replaced content with "This is cancelled."

15:32:28 <korvo> ais523: Non-determinism is a property of the machine, not an optional capability, because it's a structural property. Categorically speaking, Rel and Set don't have the same monoidal structure.

15:32:47 <korvo> I'm a little surprised to hear folks talking of trusting cryptography over proofs. Cryptography might not be well-founded.

15:34:08 <korvo> If there's interest, I could add a section to the E article, or start an entirely new article, about the design of data structures and algorithms for repeatable deterministic behavior when replicated across a network.

15:35:00 <esolangs> [[User:Hotcrystal0/User chart]] https://esolangs.org/w/index.php?diff=153755&oldid=153754 * Hotcrystal0 * (+98)

15:35:21 <korvo> FWIW I think that worrying about pointer values is already too low-level to talk about determinism, unless you want the *underlying machine* to behave deterministically and you're specifying *its* behavior instead of the algorithm under study.

15:41:14 <esolangs> [[User talk:Gilbert189]] https://esolangs.org/w/index.php?diff=153756&oldid=153748 * Gilbert189 * (+124)

15:42:43 <esolangs> [[User:Hotcrystal0/List of users who are also on the TBG forums]] https://esolangs.org/w/index.php?diff=153757&oldid=153752 * Gilbert189 * (+16)

15:43:16 <ais523> <korvo> ais523: Non-determinism is a property of the machine, not an optional capability ← I meant at the language level – you can define a language such that anything that allows the program to observe nondeterminism requires a value of a particular type to use

15:43:47 <ais523> I do appreciate that deterministic behaviour cross-network is much harder than doing it in a single-threaded program, though!

15:45:13 <korvo> Sure. Actually, that's another instance of the same idea; The Network is always partially ordered, but it's fairly simple to implement a system that builds an idempotent commutative monoid ("CRDT") on top.

15:45:18 <esolangs> [[User talk:Gilbert189]] https://esolangs.org/w/index.php?diff=153758&oldid=153756 * Hotcrystal0 * (+159)

15:45:30 <esolangs> [[User talk:Gilbert189]] https://esolangs.org/w/index.php?diff=153759&oldid=153758 * Hotcrystal0 * (+51)

15:46:06 <esolangs> [[User:Hotcrystal0/List of users who are also on the TBG forums]] https://esolangs.org/w/index.php?diff=153760&oldid=153757 * Hotcrystal0 * (+17)

15:46:08 <korvo> But if that's acceptable, then I think that Galois theory of algorithms is *extremely* relevant, as it concerns when two different algorithms implement the same function, or when two different programs implement the same algorithm, etc.

15:49:33 <korvo> ais523: Also, I know that folks were fixated on timing, but there are some non-deterministic systems that have deterministic outputs modulo timing and throughput; the classic example is Petri nets, which model non-deterministic stoichiometry of chemical reactions.

15:50:25 <korvo> I might be coming at this from a different angle; I long ago realized that questions like "But how will I do I/O if I'm isolated?" are not even wrong.

15:50:33 <esolangs> [[Talk:IPALang]] N https://esolangs.org/w/index.php?oldid=153761 * Hotcrystal0 * (+183) Created page with "Does this mean every program can be pronounced? So this esolang has a spoken form as well? ~~~~"

16:38:40 <ais523> is there a usermode way to clear the branch predictor state on Intel x86-64 processors? (I know you can clear the indirect branch predictor nowadays because of Spectre – but don't think that affects the predictor for direct branches, although I might be wrong)

16:39:33 <ais523> the purpose would be to be able to benchmark code without the branch predictor already being trained on it

16:50:25 <esolangs> [[User talk:Gilbert189]] https://esolangs.org/w/index.php?diff=153762&oldid=153759 * Gilbert189 * (+253)

16:50:34 <esolangs> [[User talk:Gilbert189]] https://esolangs.org/w/index.php?diff=153763&oldid=153762 * Gilbert189 * (+0)

17:07:56 <esolangs> [[Topple]] M https://esolangs.org/w/index.php?diff=153764&oldid=153408 * H33T33 * (+261)

17:17:18 <esolangs> [[Topple]] M https://esolangs.org/w/index.php?diff=153765&oldid=153764 * H33T33 * (+356)

17:18:59 <esolangs> [[Topple]] M https://esolangs.org/w/index.php?diff=153766&oldid=153765 * H33T33 * (+0)

17:23:13 <esolangs> [[Braincrap]] N https://esolangs.org/w/index.php?oldid=153767 * Huywallz * (+4032) Created page with "{{lowercase}} {{infobox proglang | name = Braincrap | paradigms = imperative | author = [[Huywallz]] | year = [[:Category:2025|2025]] |memsys=[[:Category:Cell-based|Cell-based]] | class=[[:Category:Turing complete|Turing complete]] | majorimpl = C | influence = [[Bra

17:29:01 <esolangs> [[User:Hakerh400/Rectangle with rational side length]] N https://esolangs.org/w/index.php?oldid=153768 * Hakerh400 * (+9846) Created page with "=== Statement === Any rectangle that is tiled with finitely many rectangles that have at least one rational side, also has at least one rational side. === Proof === We perform strong induction on the number of small rectan

17:29:22 <esolangs> [[User:Hotcrystal0/List of users who are also on the TBG forums]] https://esolangs.org/w/index.php?diff=153769&oldid=153760 * Hotcrystal0 * (+48)

17:29:24 <esolangs> [[User:Hakerh400]] https://esolangs.org/w/index.php?diff=153770&oldid=153537 * Hakerh400 * (+93) /* Proofs */

17:31:38 <esolangs> [[User:Hakerh400/Rectangle with rational side length]] https://esolangs.org/w/index.php?diff=153771&oldid=153768 * Hakerh400 * (+3) /* Statement */

17:34:20 <esolangs> [[User:Hakerh400/Rectangle with rational side length]] M https://esolangs.org/w/index.php?diff=153772&oldid=153771 * Hakerh400 * (+1) /* Proof */

17:40:01 <esolangs> [[User:Hakerh400/Rectangle with rational side length]] https://esolangs.org/w/index.php?diff=153773&oldid=153772 * Hakerh400 * (+95)

17:44:42 <esolangs> [[User:Hakerh400/Rectangle with rational side length]] https://esolangs.org/w/index.php?diff=153774&oldid=153773 * Hakerh400 * (+0)

17:46:47 <esolangs> [[User:Hakerh400/Rectangle with rational side length]] M https://esolangs.org/w/index.php?diff=153775&oldid=153774 * Hakerh400 * (+2)

17:48:24 <esolangs> [[User:Hotcrystal0/Deep]] https://esolangs.org/w/index.php?diff=153776&oldid=153736 * Hotcrystal0 * (-28)

17:49:40 <esolangs> [[User:Hotcrystal0/Deep]] https://esolangs.org/w/index.php?diff=153777&oldid=153776 * Hotcrystal0 * (+52)

17:49:52 <esolangs> [[User:Hotcrystal0/Deep]] https://esolangs.org/w/index.php?diff=153778&oldid=153777 * Hotcrystal0 * (+3)

18:10:55 <esolangs> [[User:Hotcrystal0/Deep]] https://esolangs.org/w/index.php?diff=153779&oldid=153778 * Hotcrystal0 * (-1)

18:13:31 <esolangs> [[User:Hotcrystal0/Deep]] https://esolangs.org/w/index.php?diff=153780&oldid=153779 * Hotcrystal0 * (+203)

18:15:02 <zzo38> Another way to avoid some of the non-determinism is to design the CPU to avoid the issues that cause this problem. In a message above, ais523 had mentioned conditions a), b), c); conditions a) and b) can already easily be avoided but c) (obscure and not-widely-used CPU instructions) could be avoided by designing the CPU and instruction set.

18:15:41 <zzo38> Perhaps a variant of RISC-V could be used, since I think implementations of RISC-V and compilers that target it are probably common enough in order to do this.

18:16:49 <esolangs> [[User:Hotcrystal0/Deep]] https://esolangs.org/w/index.php?diff=153781&oldid=153780 * Hotcrystal0 * (+236)

18:20:24 <esolangs> [[User:Hotcrystal0/Deep]] https://esolangs.org/w/index.php?diff=153782&oldid=153781 * Hotcrystal0 * (-6)

18:21:11 <esolangs> [[User:Hotcrystal0/Deep]] https://esolangs.org/w/index.php?diff=153783&oldid=153782 * Hotcrystal0 * (-7)

18:22:20 <zzo38> Deterministic allocation is clearly what is necessary too, which is also mentioned. As b_jonas has mention there is also multiple grades of deterministic execution.

18:23:36 <zzo38> It is not necessary to forbid timeouts that are set by other programs that have permission to handle timing and to control the permission of that program, but otherwise timeouts cannot be set (although a program could ask someone else to do so, if it has a capability to send the message to the other one; the sender doesn't know that the receiver actually will do so, but conventions will specify what is expected).

19:20:37 <ais523> perhaps timeouts could be measured in terms of CPU instructions (or the equivalent) rather than time

19:36:27 <HackEso> olist <https://www.giantitp.com/comics/oots1320.html>: shachaf oerjan Sgeo boily nortti b_jonas Noisytoot

19:52:43 <zzo38> That could be another way, although I had also describe how capabilities can be used if you do want to measure time.

19:56:03 <esolangs> [[User talk:Zopium]] https://esolangs.org/w/index.php?diff=153784&oldid=153661 * Zopium * (+86) /* Quote */

20:08:21 <b_jonas> ais523: you can do that, but then you can't use caches efficiently, so I think some more complicated system might be worth. I was thinking that you could have five special pointer registers (one of them the stack pointer) that each point to a one page long array, each come with a mask of 64 bits tracking which of the 64 cache lines starting from that you have already accessed since you modified that

20:08:27 <b_jonas> index register, and if you access a value through that index register in a cache line that you've already loaded then it's presumed to likely be in the L1 cache and so costs less nominal time. Or you could have something higher level where you can do array loops with multiple simd instructions cheaper.

20:08:39 <b_jonas> In any case you'd pre-calculate the nominal time cost in each block between jumps.

20:09:41 <b_jonas> Or I guess you could have just the top of the stack fast plus four one-page long by-value vector registers that are faster to access.

20:10:23 <b_jonas> it's a hard question and I might not want to eliminate all the timing side channels

20:40:34 <ais523> if the processor used caches a lot that would simply just effectively make the timeout shorter, in order to maintain a deterministic moment-of-timing-out according to the program's execution

20:41:02 <ais523> (the idea is to eliminate timing side channels not by making the time constant but by making the time unobservable)

20:42:42 <b_jonas> ais523: I'm thinking of code where most of the time is spent on instructions operating on caches, which is typical in some numeric computation. So if you're counting instructions to set timeouts then you'll grossly overestimate how slow the code is and time it out early. But then that's probably not the kind of code that you will want to run in the deterministic interpreter, especially if you give that

20:42:48 <b_jonas> interpreter access to some high-level builtin functions that are deterministic, like for compression/decompression or cryptographic primitives.

20:44:32 <esolangs> [[Deadfih]] https://esolangs.org/w/index.php?diff=153785&oldid=152788 * Zopium * (+39) /* Implementation */

20:47:19 <b_jonas> and I guess you should run as little as possible in the deterministic interpreter context, eg. you could have graphics rendering for the user that needn't be deterministic, and it can time out in which case the UI will lag, as long as the deterministic code can't observe that

20:47:58 <b_jonas> (or observe it but only at a high latency and low throughput so the information about lag can be synchronized between the nodes)

20:49:08 <b_jonas> ais523: basically I'm playing a lot of Factorio, and it naturally makes me wonder what it takes to make a game that is both network multiplayer and can run untrusted mods

20:57:05 <esolangs> [[Language list]] M https://esolangs.org/w/index.php?diff=153786&oldid=153679 * Buckets * (+14)

20:58:13 <esolangs> [[User:Buckets]] M https://esolangs.org/w/index.php?diff=153787&oldid=153680 * Buckets * (+13)

20:58:35 <esolangs> [[Evinocu]] N https://esolangs.org/w/index.php?oldid=153788 * Buckets * (+778) Created page with "Evinocu is an Esoteric programming language created by [[User:Buckets]] in 2022. {| class="wikitable" |- ! Commands !! Instructions |- | A() || This is A function. |- | = || Sets the Function/variable to Something on the other Side. |- | [i] || Input. |- | [Letter other

20:58:51 <esolangs> [[Deadfih]] https://esolangs.org/w/index.php?diff=153789&oldid=153785 * Zopium * (-64) /* Implementation */

22:42:09 <zzo38> TeX uses floating point numbers which may be differenton different computers but does not allow their results to affect any decisions made for typesetting other than the positions of some things.

23:27:53 <esolangs> [[User:Hotcrystal0/List of users who are also on the TBG forums]] https://esolangs.org/w/index.php?diff=153790&oldid=153769 * PkmnQ * (+4)

23:52:38 <esolangs> [[User:Hotcrystal0/Deep]] https://esolangs.org/w/index.php?diff=153791&oldid=153783 * I am islptng * (+540) You can revert if I am not allowed to edit!