00:13:24 -!- ais523 has quit (Quit: quit).
00:31:43 -!- Melvar has quit (Ping timeout: 246 seconds).
00:45:51 -!- Melvar has joined.
01:49:25 -!- 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).
03:38:13 <esolangs> [[Square-like]] https://esolangs.org/w/index.php?diff=168121&oldid=168100 * Yayimhere2(school) * (+60) /* Syntax & semantics */
03:49:33 <esolangs> [[Emmental]] https://esolangs.org/w/index.php?diff=168122&oldid=148993 * Yayimhere2(school) * (+115) /* See also */
05:08:49 <esolangs> [[User talk:Chris Pressey]] https://esolangs.org/w/index.php?diff=168123&oldid=90288 * Yayimhere2(school) * (+150) /* Controversial */
06:10:38 -!- Sgeo has quit (Ping timeout: 256 seconds).
06:19:12 -!- Sgeo has joined.
06:29:22 -!- Sgeo_ has joined.
06:30:37 -!- Sgeo has quit (Ping timeout: 264 seconds).
06:54:33 <esolangs> [[Apraxia]] N https://esolangs.org/w/index.php?oldid=168124 * Yayimhere2(school) * (+2953) Created page with "'''Apraxia''' is a [[Category:Pattern-based|pattern-based esolang]] created by [[User:Yayimhere]], after being disappointed by the use of the before mentioned term. In Apraxia, every string of length <code>1</code> is valid as code. Apraxia is quite complex c
06:58:39 <esolangs> [[Apraxia]] https://esolangs.org/w/index.php?diff=168125&oldid=168124 * Yayimhere2(school) * (+220)
07:02:11 -!- Sgeo_ has quit (Read error: Connection reset by peer).
07:09:54 <esolangs> [[User:Yayimhere]] https://esolangs.org/w/index.php?diff=168126&oldid=168057 * Yayimhere2(school) * (+14) /* esolangs */
07:14:24 <esolangs> [[Delta Relay]] M https://esolangs.org/w/index.php?diff=168127&oldid=154072 * ThrowAwayLurker * (+4) Changed punctuation and capitalization
07:16:54 <esolangs> [[Square-like]] https://esolangs.org/w/index.php?diff=168128&oldid=168121 * Yayimhere2(school) * (-5) /* Syntax & semantics */
07:17:49 <esolangs> [[ObjLang]] M https://esolangs.org/w/index.php?diff=168129&oldid=122882 * ThrowAwayLurker * (+31) Added distinguish to Obj
07:18:27 <esolangs> [[Obj]] M https://esolangs.org/w/index.php?diff=168130&oldid=139777 * ThrowAwayLurker * (+36) Added distinguish to ObjLang
07:33:12 -!- sprout_ has changed nick to sprout.
08:01:37 <esolangs> [[Square-like]] https://esolangs.org/w/index.php?diff=168131&oldid=168128 * Yayimhere2(school) * (+80) /* Syntax & semantics */
08:11:03 <esolangs> [[STABS-MOD]] N https://esolangs.org/w/index.php?oldid=168132 * Yayimhere2(school) * (+2072) Created page with "{{WIP}} '''STABS-MOD''', an acronym for "STAck Based String MODification language", is a language created based on an idea for a [[Minsky Machine]] translation into [[Square-like]]. It is quite the strange stack(well, dequeue) based language. It is currentl
08:13:46 <esolangs> [[STABS-MOD]] https://esolangs.org/w/index.php?diff=168133&oldid=168132 * Yayimhere2(school) * (+17) /* Commands */
08:13:59 <esolangs> [[STABS-MOD]] https://esolangs.org/w/index.php?diff=168134&oldid=168133 * Yayimhere2(school) * (+17) /* Commands */
08:15:30 <esolangs> [[STABS-MOD]] https://esolangs.org/w/index.php?diff=168135&oldid=168134 * Yayimhere2(school) * (-2) /* Commands */
08:40:19 -!- tromp has joined.
08:41:53 <esolangs> [[Square-like]] https://esolangs.org/w/index.php?diff=168136&oldid=168131 * Yayimhere2(school) * (+97) /* Syntax & semantics */
08:44:48 <esolangs> [[STABS-MOD]] https://esolangs.org/w/index.php?diff=168137&oldid=168135 * Yayimhere2(school) * (+93) /* Commands */
08:51:01 <esolangs> [[Notwise Cyclic Tag]] N https://esolangs.org/w/index.php?oldid=168138 * Yayimhere2(school) * (+421) Created page with "'''Notwise Cyclic Tag''' or '''NCT''' is a modified [[BCT]]. It was created to prove [[STABS-MOD]] turing complete. == NCT programs == A NCT program is any finite string of commands, executed as follows: {| class="wikitable" ! Symbol !! Meaning |-
09:41:39 <esolangs> [[Fillin]] N https://esolangs.org/w/index.php?oldid=168139 * Yayimhere2(school) * (+1172) Created page with "'''Fillin''' (pronounced \ii\) is an esolang created by [[User:Yayimhere]] after being dissatisfied by [[Square-like]], another esolang they made. Fillin functions by filling in its own program again and again. == Memory == Fillin has a stack. This stack is f
09:44:35 <esolangs> [[Fillin]] https://esolangs.org/w/index.php?diff=168140&oldid=168139 * Yayimhere2(school) * (+158) /* Leave */
09:45:03 <esolangs> [[Fillin]] https://esolangs.org/w/index.php?diff=168141&oldid=168140 * Yayimhere2(school) * (+44)
09:47:27 <esolangs> [[Fillin]] https://esolangs.org/w/index.php?diff=168142&oldid=168141 * Yayimhere2(school) * (+46) /* Commands */
09:48:24 <esolangs> [[Fillin]] https://esolangs.org/w/index.php?diff=168143&oldid=168142 * Yayimhere2(school) * (-146) /* Memory */
09:48:37 <esolangs> [[Fillin]] https://esolangs.org/w/index.php?diff=168144&oldid=168143 * Yayimhere2(school) * (-21) /* Commands */
10:01:11 -!- Taneb has joined.
10:02:06 <esolangs> [[Incident]] https://esolangs.org/w/index.php?diff=168145&oldid=67279 * Yayimhere2(school) * (+52) /* See also */
10:16:14 -!- Yayimhere has joined.
10:16:34 -!- Yayimhere has quit (Client Quit).
10:27:38 <esolangs> [[User:RaiseAfloppaFan3925]] https://esolangs.org/w/index.php?diff=168146&oldid=168112 * RaiseAfloppaFan3925 * (-2238)
10:42:51 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
10:50:44 -!- tromp has joined.
12:42:36 -!- amby has joined.
12:56:10 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
13:00:49 -!- ais523 has joined.
13:02:12 -!- tromp has joined.
13:35:32 <esolangs> [[Delta Relay]] https://esolangs.org/w/index.php?diff=168147&oldid=168127 * Ais523 * (+0) partial rv: the bullet points in the "any of the following algorithms" list start in the middle of the sentence, so the first word of the bullet point is not capitalised because it occurs mid-sentence and is not a proper noun
13:51:47 <esolangs> [[Talk:Fire]] N https://esolangs.org/w/index.php?oldid=168148 * Waffelz * (+91) Created page with ""fire" -~~~~"
14:25:26 -!- impomatic has joined.
14:37:15 -!- Sgeo has joined.
14:42:04 -!- impomatic has quit (Quit: Client closed).
14:47:17 -!- lynndotpy6093 has quit (Quit: bye bye).
14:48:31 -!- lynndotpy6093 has joined.
15:23:42 -!- Taneb has quit (Ping timeout: 256 seconds).
15:24:55 <esolangs> [[Talk:Fire]] https://esolangs.org/w/index.php?diff=168149&oldid=168148 * Esolangist alt * (+176) Esolangist alt
15:26:12 <esolangs> [[Bliss]] M https://esolangs.org/w/index.php?diff=168150&oldid=168110 * H33T33 * (+204)
15:26:53 <esolangs> [[2 commands :(]] N https://esolangs.org/w/index.php?oldid=168151 * * (+1040) Created page with "'''2 commands :(''' is a language by ~~~, made as the sequel to [[3 commands :)]]. 2 commands :( has 2 commands and 2 cells. ==Commands== {| class="wikitable" | 1 || If cell 2 is 256, output cell 1 as a number. If it is 257, output it as an ASCII character. If it is 258
15:32:43 -!- DOS_User_webchat has joined.
15:33:00 -!- DOS_User_webchat has changed hostmask to ~DOS_User_@user/DOS-User:11249.
15:35:51 -!- DOS_User_webchat has quit (Remote host closed the connection).
15:59:43 <esolangs> [[Bliss]] M https://esolangs.org/w/index.php?diff=168152&oldid=168150 * H33T33 * (-1)
16:05:53 <esolangs> [[Bliss]] https://esolangs.org/w/index.php?diff=168153&oldid=168152 * Aadenboy * (+1) fix tag
16:19:45 -!- pool has quit (Read error: Connection reset by peer).
16:21:43 -!- pool has joined.
16:28:02 -!- Lord_of_Life_ has joined.
16:29:08 -!- Lord_of_Life has quit (Ping timeout: 256 seconds).
16:29:22 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
16:44:31 <esolangs> [[Extended beescript]] N https://esolangs.org/w/index.php?oldid=168154 * Esolangist alt * (+1937) Esolangist alt
16:53:26 <esolangs> [[User:Hammy]] https://esolangs.org/w/index.php?diff=168155&oldid=167740 * Esolangist alt * (+223) Esolangist alt
16:58:37 -!- Yayimhere has joined.
17:03:09 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
17:05:37 <ais523> a bit tired, also there's a rainstorm over the UK at the moment so it's making it difficult to do things outdoors
17:06:23 <Yayimhere> (i am not quite surprised you arent working on much, because you have already worked on a whole lot of things)
17:07:26 <ais523> I find it hard to get enough mental energy together to focus on anything in particular, it can take days
17:08:09 <ais523> atm I'm mentally working on a replacement for one of the most fundamental standard library types in Rust (specifically Box)
17:08:18 <ais523> but am having trouble working out the exact soundness conditions
17:09:16 <ais523> even if I work it out, it might be hard to persuade the Rust developers to accept the change, but I still want to figure out how it's supposed to look instead and think I can make it backwards-compatible with stable code
17:09:34 <ais523> being in #esolangs means that you can try to reimagine things that most language developers wouldn't dare to
17:10:57 <ais523> trying is kind-of different from succeeding
17:11:04 <ais523> I'm actually trying to get something *else* into Rust which I think has a better chance
17:11:29 <ais523> but I was trying to write a prototype, and got stuck on Box not working the way I needed it to, so I'm writing my own Box so that i can use it to write the prototype of the other feature
17:12:13 <ais523> this has been my life for the past 5 years or so, try to write a program, find that the language isn't quite right for writing the program in, try to fix the language
17:12:32 <ais523> then decide I want a prototype to demonstrate my ideas more clearly, but that's also a program, so the cycle repeats
17:12:44 <ais523> until it starts touching on ever more fundamental parts of the language
17:13:01 <Yayimhere> has any of your esolangs resulted from this
17:13:23 <ais523> doing this on Rust, no, because the resulting language changes end up too practical to really be esolangs
17:13:36 <ais523> it's given me a few ideas for intermediate representations (which are languages used internally within compilers)
17:13:45 <Yayimhere> but like in general, not this specifically
17:13:56 <ais523> which are fairly esoteric as intermediate representations go, but IRs still generally aren't considered to be esolangs
17:14:35 <esolangs> [[User:Yayimhere]] https://esolangs.org/w/index.php?diff=168156&oldid=168126 * Yayimhere2(school) * (+0) /* Favorite esolangs: */
17:15:24 <esolangs> [[User:Yayimhere]] https://esolangs.org/w/index.php?diff=168157&oldid=168156 * Yayimhere2(school) * (+8) /* Favorite esolangs: */
17:15:55 <ais523> I think people are still surprised that we got the URL https://esolangs.org/wiki//// to work
17:16:02 <ais523> URLs don't normally work like that
17:17:31 <ais523> (I'm not involved in the webserver/hosting side of esolangs.org so I don't know how difficult it was)
17:17:57 -!- tromp has joined.
17:18:07 <esolangs> [[User:Ractangle]] M https://esolangs.org/w/index.php?diff=168158&oldid=165846 * Ractangle * (+17) /* Esolangs */
17:18:41 <esolangs> [[Filename "xxx" doesn't seem to be a valid filename. Please check if the filename your trying to execute is written correctly]] M https://esolangs.org/w/index.php?diff=168159&oldid=163160 * Ractangle * (-190) /* Python */
17:19:57 <Yayimhere> for what im working on, im making an esolang with another esolanger
17:20:16 <Yayimhere> in which a program generates programs, put them on a wheel, and reject or accept them
17:21:40 <ais523> what does the wheel do?
17:22:53 <ais523> ah, so it's your equivalent of a stack or tape?
17:24:09 <Yayimhere> but its a wheel cuz wee spin it around in a cycle
17:24:12 <ais523> hmm, now I'm thinking about how, in addition to having stacks and tapes and queues to store data, languages often conceptually have something similar to a stack or tape or queue to hold the program
17:24:37 <Yayimhere> thats an interesting concept for an esolang
17:24:45 <ais523> BF is like the program is on a stack, because when you encounter the start of a loop and it's taken, you push a copy of the loop body in front of the loop
17:25:10 <ais523> (this is actually how I implemented it when I wrote a BF interpreter in Esimpl, which is designed to map onto a lot of other simple esolangs so they would probably implement it the same way)
17:25:23 <ais523> likewise, Underload treats the program like a stack because ^ pushes onto the start of the program
17:26:12 <ais523> meanwhile, in languages like cyclic tag and the I/D machine, the program acts like a queue because the easiest way to implement the implicit loop is, after running a command, you push that command onto the end of the program
17:26:46 <ais523> and in languages like Unefunge, the program is there as a static entity but you can move the instruction pointer back and forward through it and it can move in either direction, so the program behaves like a tape
17:27:00 <ais523> I'm not sure if there's a pattern or important concept here but it's interesting to think about
17:27:10 <esolangs> [[8ial]] M https://esolangs.org/w/index.php?diff=168160&oldid=166147 * Ractangle * (-49) /* Interpreter */
17:27:23 <Yayimhere> I guess its a method for creating a self modifying language
17:27:30 <ais523> maybe this is somehow connected to the way that tag systems are better at interpreting counter machines than tag systems, but counter machines are better at intepreting tag systems than counter machines
17:28:05 <ais523> (when *compiling* it behaves more sensibly, normally tag systems compile most easily into other tag systems and counter machines into other counter machines)
17:28:46 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
17:29:29 <esolangs> [[8ial]] M https://esolangs.org/w/index.php?diff=168161&oldid=168160 * Ractangle * (-51) /* Syntax */
17:29:34 <Yayimhere> this makes me wonder if there is a fun way to make a self modifying Apraxia variant
17:30:38 <Yayimhere> Apraxia is most definitely trivial in a stack
17:30:39 -!- tromp has joined.
17:30:40 <b_jonas> "trying to get something *else* into Rust which I think has a better chance" => I hope it's a better replacement for the whole format! mechanism, because that's the part that I'd most like to replace. But it's tricky, because the current format! parses the format template at compile time, which is very useful, not really because of performance but to find type errors at compile time, but isn't trivial
17:31:22 <b_jonas> I wouldn't have guessed that you want to replace Box, that one is surprising.
17:31:46 <ais523> b_jonas: I (and others) realised a while ago that Rust had an important missing abstraction
17:31:55 <ais523> but it's only very recently that I realised that it's a generalisation of Box
17:32:31 <ais523> the difference from current Rust Box is that the current Box manages an allocation itself and also manages the lifetime of the value inside the box itsefl
17:33:15 <ais523> which is a special case of my generalised Box (which I'm calling Box2), which wraps around an object representing an allocation, and manages the lifetime of the value inside the Box but delegates the management of the allocaiton itself
17:34:41 <ais523> so Box::<T>::new(t) would be sugar for Box2::<T>::new_at(x, GlobalAllocator::new_allocation::<T>()), but this would then allow you to start using other allocation-like things instead of actual allocations
17:35:04 <b_jonas> "got the URL https://esolangs.org/wiki//// to work" => I don't find that surprising. like, the RFCs say that . and .. components between slashes are supposedly special in URLs, but they also say that proxies must not rewrite any part of the URL with the exception that if there's no path after the hostname they can add a single slash, and the webservers can just interpret URLs however they want and tell
17:35:10 <b_jonas> proxies how to cache pages, so nobody actually enforces the theoretical rules about URLs
17:35:17 <b_jonas> and I think even the theoretical rules don't require that extra slashes can't have a meaning
17:35:35 <ais523> right, most webservers treat them as directory-like but there's no rule that actually says you have to
17:36:55 <b_jonas> also I think MediaWiki does this out of the box with the slahes, though you can run into problems with some other characters in article titles
17:37:24 <ais523> IIRC it used to not work, but got intentionally fixed at some point
17:37:40 <ais523> but it might have been something before MediaWiki in the chian
17:37:50 <fizzie> Hah, I *just* mentioned https://esolangs.org/wiki//// on #go-nuts yesterday.
17:38:14 <korvo> Yayimhere: It's worth asking *why* we want self-modifying systems. Often it's much easier to analyze when a system's code and data are completely separate.
17:38:24 <fizzie> Someone came by complaining that the Go standard library's router collapses consecutive slashes (or removes empty path components, whichever way you want to think of it).
17:38:44 <Yayimhere> korvo: I think the want directly comes from a challenge of not being allowed to separate them
17:38:46 <korvo> And even when we want to be able to treat code as data for runtime code generation, we can use something like multi-stage programming or two-layer types to do it safely.
17:39:01 <Yayimhere> as an estoric language's goal atleast
17:39:15 <fizzie> Which may or may not be true, they may have also misdiagnosed the issue; in any case, what I know for sure is, nginx does that by default when proxying, so a `merge_slashes off;` setting is needed for that /// link to actually work.
17:39:37 <ais523> korvo: so I think the attraction is that self-modification is both powerful and hard to reason about, which makes it an interesting challenge for programmers
17:39:51 <fizzie> (That's the before-MediaWiki thing that needed a fix. It's only an issue when using the "pretty" URLs, of course.)
17:40:06 <ais523> maybe it isn't the best thing to use in production
17:40:06 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
17:40:08 <korvo> Yayimhere: Sure. Lucky 10000: most computers today are either *Harvard* or *Von Neumann* architectures. The big difference is that a Harvard architecture doesn't allow code to be altered after it's been loaded, while a Von Neumann architecture allows code to be changed.
17:40:41 <ais523> I remember reading about someone who was using cross-modifying code as a performance optimisation, that seems to be a similar attraction
17:40:42 <Yayimhere> Korvo: i actually do prefer the concept of a Von Neumann one
17:40:52 <esolangs> [[8ial]] M https://esolangs.org/w/index.php?diff=168162&oldid=168161 * Ractangle * (-6) /* Cat program */
17:41:12 <korvo> You'll see lots of Harvard architectures being pushed for safety, and ideas that emulate it like W^X, "write XOR execute", which says that pages in memory can either be mutable or executable but not both.
17:41:57 <Yayimhere> is propably comes fro my want to be able to modify anything I want to
17:42:06 <b_jonas> fizzie: maybe I'm a wimp but I referred to it as https://esolangs.org/wiki/Slashalash in https://logs.esolangs.org/libera-esolangs/2025-10.html#lJJb . I don't think the punctuation-only one is bad for a URL, but because I think it's bad for the name of a language. Cplusplus and C-sharp are bad enough, we don't have to compete with them.
17:42:55 -!- tromp has joined.
17:43:10 <ais523> korvo: so my conceptual objection to self-modifying code that isn't extremely low level is that it really restricts what source code transformations are valid
17:43:16 <b_jonas> ais523: I don't really understand that Box thing, but I assume you'll eventually just explain it in a blog post
17:43:28 <korvo> Yayimhere: Sure. And that attitude makes sense for a single person on a single machine with no network. But how do you prevent Somebody Else from modifying anything on your machine? Once we start asking that sort of question, it becomes more attractive to make parts of the software immutable so that *nobody* can change them.
17:43:47 <ais523> b_jonas: this is normal with my ideas in early stages of development, I often don't really understand them myself
17:44:03 <Yayimhere> korvo: true. I had not really though of that, however this is for me still an esolang question
17:44:12 <korvo> ais523: Yeah. Or it makes them much more expensive, since the transformation must track the original code and any modifications that have been statically applied.
17:46:28 <esolangs> [[Apraxia]] https://esolangs.org/w/index.php?diff=168163&oldid=168125 * Yayimhere2(school) * (+14) /* Semantics */
17:47:21 <b_jonas> "so my conceptual objection to self-modifying code that isn't extremely low level is that it really restricts what source code transformations are valid" => oh yeah! that reminds me of a certain obfuscated dc short signature that reuses a string for both executing and getting its length, so if you try to modify that string to add debug statements for reverse engineering then the code breaks. that's not
17:47:27 <b_jonas> self-modifying code, but gives a similar problem. much later I wrote something like that in perl where you can't even modify any character in the string without it breaking something.
17:47:38 <ais523> korvo: the thing that bothers me about the security argument is that it isn't obvious to me that it's impossible to have secure self-modifying code
17:47:48 <b_jonas> that dc code was when I was young so I didn't yet expect that that kind of thing can happen
17:47:54 <esolangs> [[8ial]] M https://esolangs.org/w/index.php?diff=168164&oldid=168162 * Ractangle * (-18) /* Truth-machine */
17:47:54 <ais523> you could place restrictions on what modifications were allowed, or use a taint system, or the like
17:48:35 <ais523> b_jonas: it would have been much easier in A Pear Tree :-P
17:49:02 <ais523> although that runs the risk of someone finding the checksum
17:49:02 <b_jonas> yes... but then most people won't know how to run it
17:49:26 <b_jonas> whereas (especially at the time when I wrote it) everyone just had a perl interpreter already
17:49:40 <Yayimhere> ais523, me and a couple of other people was wondering about the statement that a looping counter is not possible by a PDA, since it makes sense to none of us
17:49:45 <Yayimhere> (this was stated on the black page)
17:49:51 <ais523> I wonder if you can write an interesting/nontrivial Perl program where any single addition, removal or substitution of a byte breaks the program
17:50:09 <b_jonas> wasn't there a challenge like that on Code Golf SE?
17:50:33 <ais523> see the pristine-programming tag for a whole load of variants on it
17:51:00 <ais523> Yayimhere: OK, so a push-down automaton is, basically, a stack where each element can only hold one of finitely many possibilities, plus a state machine
17:51:04 <b_jonas> any single addition would have to use something like reading __DATA__ and verifying the integrity, because otherwise it's hard to make somethign that doesn't break if you add a space at the start or end
17:51:25 <b_jonas> especially if it's just a perl script, not a polyglot or something
17:51:43 <ais523> say we want the program to output a really big number, then that number + 1, then that number + 2, and so on (and the number is bigger than anything that appears in the program)
17:51:47 <ais523> which a looping counter has to do, eventually
17:51:59 <ais523> there are only finitely many states, and only finitely many possibilities for each stack element
17:52:00 <b_jonas> and if I can just read the whole code and verify a checksum then the challenge gets trivial
17:52:22 <ais523> so the number has to be stored across a range of stack elements, and in order to read the whole number we have to keep popping the stack until they're all read
17:52:43 <ais523> but, by the time the entire number has been read, all the elements that represented it have been popped from the stack and there's nowhere else to store it
17:52:53 <Yayimhere> i assume this also applies to if we just have an integer counter?
17:52:56 <ais523> so a push-down automaton can't read a really big number without forgetting its value, and that makes the next line impossible to print
17:53:06 <ais523> yes, 1-counter machines have the same problem
17:53:14 <ais523> 2-counter machines don't, because as you read a number from one counter you can store it on the other counter
17:53:23 <Yayimhere> wait they cant do a looping counter
17:53:35 <ais523> a 1-counter machine can't, a 2-counter machine can
17:53:40 <ais523> (but 2-counter machines are Turing-complete)
17:54:58 <ais523> no, 2 counters are enough but you need other things too
17:55:25 <ais523> but 2 counters is enough *storage* for Turing-completeness, so if it's Turing-incomplete it's because the program has trouble reading or writing them reliably, or insufficiently powerful control flow
17:56:06 <Yayimhere> (this makes me very sure that TLQ is TC)
17:56:33 <ais523> usually if a 2-counter language isn't Turing-complete it's because either a) it's been contrived to make it Turing-incomplete or b) the author forgot to add a way to make values read from the counter affect the control flow
17:56:52 <ais523> or c) there's no way to create an infinite loop, I guess
17:57:16 <korvo> ais523: Mark Miller's perspective might be useful. He showed that if we safely *load* the code, and we enforce cap discipline throughout the VM, then there's no point of entry for attackers. In that sense, safe code loading is the only thing that has to be done right. But he argues that Java's parade of vulns is precisely from unsafe code loading!
17:57:32 <b_jonas> in http://www.madore.org/cgi-bin/comment.pl/showcomments?href=http%3a%2f%2fwww.madore.org%2f~david%2fweblog%2f2017-08.html%23d.2017-08-18.2460#comment-23792 I have a proof that the language (1) is equivalent to the language (1) with arrays, which seems funny because (1) apparently only has access to one stack, the call stack that holds local variables and return addresses, whereas (1) with arrays lets
17:57:38 <b_jonas> you random access arrays. of course the trick is that bignums of unbounded size are used and in the general case they will grow big, but the proof hides it nicely.
17:57:52 <ais523> korvo: I might agree but I think that the phrase "safe code loading" is carrying a lot of weight there and needs to be precisely defined
17:58:22 <korvo> Yayimhere: Yeah. We gotta be careful not to follow Miller wholesale though, as he will pied-piper us onto blockchains and cryptocurrency and augmented-reality metaverses.
17:59:06 <ais523> there's https://esolangs.org/wiki/Feed_the_Chaos which is a two-counter machine that might or might not be Turing-complete
17:59:21 <Yayimhere> (the amount of times I typed *f is incredible)
18:00:02 <ais523> I contrived that by making the control flow awkward enough that you're restricted in what you can do with values read from one counter
18:00:20 <korvo> ais523: http://www.erights.org/talks/thesis/markm-thesis.pdf Chapter 10, p93. Quoting p96, why Java is not object-cap: "The import mapping that [the user] provides cannot override some magic class names, and some of those system classes provide authority."
18:01:03 <esolangs> [[User:H33T33]] https://esolangs.org/w/index.php?diff=168165&oldid=166956 * H33T33 * (+12)
18:01:27 <esolangs> [[User:H33T33]] https://esolangs.org/w/index.php?diff=168166&oldid=168165 * H33T33 * (-9)
18:01:39 <ais523> korvo: my first thought there is "can you *make* Java an object-capability language by using a security manager to deny access to the loopholes?"
18:02:13 <ais523> I simultaneously know more about Java security managers than anyone really should, whilst not enough to do anything particularly useful with them
18:02:40 <korvo> ais523: See Miller's language Joe-E, not really worth documenting IMO. When the dust settled there remained E. Crucially, prior to this, there was Tribble's language Joule which had done the same to Smalltalk, and that gave a hint of how to do it.
18:03:50 <korvo> There's a flavor of ML called Alice. Wyvern is arguably a taming of a sort of generic OO teaching language. Monte is explicitly a taming of Python concepts. We haven't really made any object-cap languages which didn't start as taming attempts.
18:04:59 <ais523> korvo: I've been vaguely planning to write one (although it will be hard to find time to do so)
18:05:33 <ais523> actually there are significant effects on the language design, e.g. I want to keep the type system as simple as feasible to reduce the chance of soundness bugs in it
18:06:32 <ais523> I think you'd still need generics because every language needs those eventually, but am hoping to be able to keep it to a very simple version of them
18:09:34 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
18:10:29 <korvo> ais523: Oh, for sure. Last time I tried, I got Cammy, which doesn't have objects, Zaddy, which doesn't really have anything to encapsulate, and Vixen, which has the unappetizing task of taming Linux and will thus be Yet Another Taming.
18:12:01 <esolangs> [[Apraxia]] https://esolangs.org/w/index.php?diff=168167&oldid=168163 * Yayimhere2(school) * (-1) /* Semantics */
18:15:18 <korvo> ais523: I don't think I have it offhand, but somewhere in my Monte notes there is an enumeration of what *is* safe to provide to a code loader, assuming that the loading is a TC process. There can be a central dispatch object which reifies calls and sends; you can "call to call" by calling it. That's the object E in E, M in Monte, V in Vixen, etc. ASTs are legal too, so multi-stage programming is fine. E and Monte have safe quasiquotation.
18:16:09 <ais523> my mental model of safe code loading is "start with a sequence of bytes and then run some parser/verifier on it to make sure it's a valid binary for the language you're working in"
18:16:33 <ais523> another advantage of this model is that you can run it on trusted code, too, to ensure that it hasn't been miscompiled in a way that breaks cap-safety
18:16:47 <korvo> Collections are safe but heavily restricted. Only immutable collections can be identical to each other. Maps must be insertion-ordered. Lots of determinism requirements. If you've ever suffered EVM or other blockchain programming, you'll have seen this before. No gas in E, but easy enough to see where it's added.
18:17:32 <ais523> I'm increasingly coming to believe that determinism is a security property
18:18:09 <korvo> ais523: Right. But in the presence of E-style auditors, which WLOG get access to an entire object's AST, usually the compiled binary has to include the AST too. For Monte, we just shrugged and accepted this because we want the code loader to audit and certify that each imported module is immutable, and that's not something that can be wholly in user code.
18:19:32 <ais523> one thing I really want to do is a memory-safe (and capability-safe) assembly language
18:19:41 <ais523> that's basically just regular assembly language equipped with a correctness proof
18:19:48 <ais523> so the hard part is writing the proof language
18:19:55 -!- pool has quit (Read error: Connection reset by peer).
18:20:06 <ais523> this is not a new idea but I think it's an unpopular idea
18:21:14 <korvo> That could have been overkill. WASM doesn't bother doing auditors; they insist that modules are immutable, and that's really all that they use it for. Monte does something a bit more ambitious; unlike in WASM, in Monte a server can safely load *arbitrary bytes* directly into memory and try to run it, and the loading process is automatically safe by construction.
18:21:59 <korvo> The only other use of E-style auditing in Monte is transparency, so that users can write objects which invisibly decompose into their components. Very important for smart contracts but not essential for local programming.
18:22:04 -!- pool has joined.
18:26:23 <korvo> (Since somebody's going to ask: E is utterly paranoid about everything. By "load arbitrary bytes directly into memory" I mean what most folks would think of as a safe encapsulated bytestring. E assumes that having arbitrary bytes resident in memory could be a security issue; the security model defends against shellcode!)
18:26:39 -!- Yayimhere has quit (Ping timeout: 250 seconds).
18:28:33 <ais523> korvo: you're reminding me of the different methods of implementing object-capabilities in-memory at runtime (i.e. shadow capabilities versus tracing capabilities)
18:29:02 <ais523> with shadow capabilities you can't really write arbitrary bytes as the instructions to write new shadow bytes just don't exist, at best you can copy them
18:29:29 <ais523> with tracing capabiliites, you can write arbitrary bytes but what they mean is context-dependent and you can't put them into a context where they would represent a capability
18:29:49 -!- Yayimhere has joined.
18:31:01 <korvo> Sometimes I think of it as a Veil or maya. A Monte bytestring like b`this` can't *do* anything; its methods are all just plain old data. If we take something behind the Veil like m`fn { "this" }` then we can *do* something, but that quasiquotation happened before the program started running, with the authority to do pre-delegated.
18:32:06 <korvo> Smalltalk tries to have it both ways with CompiledMethod. The issue is that decompiling an object is an authority! It really shouldn't be delegated to the safe scope where code is loaded.
18:32:48 <ais523> one of my beliefs is that most languages, even ones that aim for safety, have too much ambient authority / things you can do without capabilities
18:33:04 <korvo> In E and Monte, we forbade catching exceptions. I mean, syntactically one can do it, but actually *unsealing* and examining them is an unsafe cap. As a result, most code assumes that it's never erroring, since it can't recover from errors anyway. It's safe to create a delimited continuation and pass *that* into subroutines, though.
18:33:56 <ais523> hmm, interesting – what was the reasoning behind banning that rather than trying to make it safe? (fwiw I've also had thoughts along those lines but want to see if yours are the same)
18:34:35 <korvo> Yeah! I don't have unveil() on Linux but I'm going to follow that sort of strategy for Vixen. The filesystem is behind the Veil, along with most binaries, and the only safe action is to pass messages by composing pre-delegated references in the local scope.
18:35:45 <korvo> Oh, making it safe is a big hassle because, in general, the catcher shouldn't have the authority to receive control flow that it didn't originally have. So when an exception is thrown, only the thrower really has the authority to catch it, but the no-stale-stack-frames rule means that the thrower is going to soon be reaped, so *nobody* ought to be allowed to catch it.
18:35:57 <korvo> And this is why we were sad to see both Go and Rust evolve the ability to catch panics.
18:36:39 <ais523> so my opinion on this is a bit different – I think that throwing an exception should destroy everything the thrower has authority to write to
18:36:52 <ais523> so from my point of view, it doesn't create stale stack frames
18:36:58 <korvo> Delimited continuations work around this by allowing a subroutine to have precisely the delegated control flow that the caller was using. E requires continuations to expire after they're used once. We say that they're "single-shot" or "single-use" delimited continuations. For jargon we call them "ejectors".
18:37:33 <Yayimhere> Hello, i have a little bit of a problem. I need an expression language that takes any bit string as input, however the output is always a 0 or 1. Each expression must also, however, be able to be of any length
18:38:21 <korvo> Oh, for sure. The entire stack frame gets torn down. If a caller uses an ejector, then usually they wanted to abort their control flow anyway. In Monte, IIRC the idiom is m`throw.eject(ej, reason)` and if ej is none then it throws with the global sealer so nobody can catch it.
18:38:50 <Yayimhere> korvo: is that a response to me or???
18:39:07 <ais523> Yayimhere: you haven't stated hte problem yet, just the situation it occurred in
18:39:14 <ais523> so we're waiting for the question
18:39:31 <Yayimhere> my question is: is there any such language
18:39:41 <korvo> ais523: Oh, I haven't mentioned Midori! A *lot* of this traces through Duffy et al. at Microsoft Research. They independently came to the same conclusion as E's team and their error model involves aborting stack frames too. Their path forward is in Fuchsia; you can follow the color names to see more of that.
18:40:12 <ais523> I'm not sure if there's any language designed specifically like that, but it would be easy to take an existing language that allowed any bit string of any length, then change the output format
18:40:43 <ais523> korvo: huh, so Midori and Fuschia both being names of colors isn't a coincidence?
18:40:57 <Yayimhere> shortly any function F(x) must be either 1 or 0, but must also rely on x
18:41:48 <korvo> ais523: Yeah, even the corporate teams have a bit of name fun.
18:42:50 <korvo> Yayimhere: What do you mean by "each expression" and "any length"? Assuming you've chosen a finite alphabet, you can't have infinitely many programs represented by expressions of length 1.
18:43:54 <ais523> korvo: you just suddenly made me realise that I don't know of any esolangs with an infinite alphabet, other than those which allow arbitrary integers to be commands
18:44:23 <ais523> Incident I guess? but it's debatable whether its alphabet is Incident tokens or bytes
18:45:20 <Yayimhere> korvo: Ok so, what im saying is, for any bit string input N and expression of just the function M, then it must be either 1 or 0. But then for an expression of just MX then X must be the one that returns a single bit, and M must(be allowed to) return more
18:46:00 <Yayimhere> ais523: maybe this is "plugging" but I recently created a language that maybe kinda technically has an infinite alphabet? maybe?
18:46:23 <ais523> sometimes alphabets are hard to define
18:46:42 <Yayimhere> you could use any symbol out of an infinite alphabet
18:46:43 <ais523> I used to think that the syntax was the least important part of programming, but then I came across codegolf sites that do interesting things with it
18:47:04 <ais523> the hundreds-of-languages polyglot actually cared about all those BF derivatives that just change the commands
18:47:42 <ais523> and some of them were very different from others to fit into the polyglot, mostly based on how commonly their commands appeared in other languages' source code
18:48:07 <korvo> Yayimhere: The reason for that assumption is to try to figure out how much you are *not* asking for expressions representing (N → 2) → 2, the type of functions from bitstrings to booleans. A *lot* has been said about this type and types like it, but I'd like to avoid confusing you or linking you to unreadable maths.
18:49:14 <Yayimhere> korvo: i do not really understand that sentence
18:49:25 <Yayimhere> which assumption is being mentioned
18:49:43 <korvo> ais523: Automorphisms of syntax are trivial: you can have any of them. Automorphisms of semantics are trivial: there aren't any. I admit a lifelong difficulty in recognizing this distinction.
18:50:26 <korvo> Yayimhere: Well, I'm trying to figure out whether you're working with a finite alphabet or infinite alphabet. Like ais523 says, an infinite alphabet might as well be the natural numbers N, and a finite alphabet might as well be the Booleans 2.
18:50:43 <ais523> korvo: which category are you doing the morphisms in?
18:51:24 <korvo> Like, yes, there have been so many such languages! But the *interpretation* of them is what matters, and computability theory's entire point is that there are limitations on how we interpret bitstrings.
18:52:34 <korvo> ais523: Syntax gets the category of sets; it's just about labels for stuff and algebraic trees of stuff. Semantics gets, well, the category of semantics for whatever programming system we're talking about. And physics generally doesn't commute its operators, so the semantics of a physical machine won't commute either. (I think we talked about Galois-Yanofsky theory before?)
18:53:03 <ais523> korvo: ah so this is specific to *denotational* semantics
18:53:27 <ais523> but that's not the only, or even most common, way to do a semantics
18:55:26 <esolangs> [[Place]] https://esolangs.org/w/index.php?diff=168168&oldid=167474 * Hammy * (+34)
18:55:53 <korvo> Yeah, it's not a great slogan once we start implementing languages relative to other languages. Yayimhere, ais523 refers to operational semantics, which are often what we want to see when you're *implementing* a language. This is why we think it'd be great for you to continue learning Python and *implement* your languages; you will get an intuition for what the machine can do and how to do it.
18:56:30 <ais523> korvo: I'm actually not totally sure that there are no sorts of semantics other than operational and denotational
18:56:35 <Yayimhere> (my biggest issue in implementation is like, syntax work, on finding each command)
18:56:38 <ais523> although I haven't seen any others used
18:57:29 <korvo> ais523: But if you give me a rewrite system, or anything that I can put a refinement system or Hoare system onto, then I can give you a *native type theory*, which is the category of all possible denotational semantics; it's the category of functors from syntax to that rewrite system. In this sense, most languages admit a category, and it can be given nice dependent types that line up with language-specific behaviors.
18:58:23 <korvo> Such a category is automatically a Grothendieck topos, so it's a place where people can do general maths. This could help explain why so many programmers develop a language-specific way of thinking that repeatedly fails to generalize (the so-called "expert beginner" phenomenon)
18:58:35 <ais523> trying to remove nontrivial equivalences is basically the point of denotational semantics, and that's most interesting when it's constructive
18:58:52 <esolangs> [[Special:Log/newusers]] create * Uff20xd * New user account
19:01:07 <Yayimhere> I know there were some issues with my language, but uh, I came up with a way to do it
19:04:09 <korvo> ais523: TBH I think operational semantics just kick the can. It can be useful to do that, say in electrical engineering, but it's just precomposition with the denotational semantics of something else.
19:04:14 <ais523> korvo: in my PhD I worked quite a lot with game semantics, which is basically a denotational semantics constructed as follows: you imagine the program and its free variables (and environment, modeled as a free variable) as though they were Smalltalkish objects, and produce an execution trace which is a list of all the messages sent to and from the program, then the semantics of a program is the set of all possible execution traces that it could have
19:04:44 <ais523> and that got me thinking that, in effect, a denotational semantics category is just a way of describing what your program's environment and free variables are
19:05:50 <korvo> Yeah. And it doesn't have to have a monad underneath, although that turns out to be convenient because computation is monadic (and interaction is comonadic) in general.
19:05:59 <esolangs> [[Esolang:Introduce yourself]] https://esolangs.org/w/index.php?diff=168169&oldid=167999 * Uff20xd * (+158)
19:06:11 <ais523> right, there usually is some extra structure in practice, but I don't think that's inherently required
19:06:42 <korvo> FWIW we call the possible nondeterministic responses to a fixed input message the *spectrum of an actor*, or at least that's the name I used when arguing against Carl Hewitt's crankery. Hewitt argued that a counter actor that starts from 0 and repeatedly increments itself is super-Turing; I argue that it merely has the natural numbers as its spectrum.
19:07:00 <ais523> you could just come up with a completely arbitrary set of execution traces and it would describe a program in some language (although you might have to add causality restrictions to make it computable)
19:07:35 <esolangs> [[Esolang:Introduce yourself]] https://esolangs.org/w/index.php?diff=168170&oldid=168169 * Uff20xd * (+29)
19:08:16 <ais523> maybe not even that, if you have a sufficiently reliable environment
19:08:49 <ais523> like, the program might not have to be uncomputable if it has a requirement to be run in an environment that ensures it'll always continue giving input that the program can handle
19:08:58 <korvo> Yayimhere: What did you come up with?
19:09:00 <ais523> and not stop early on an impossible trace
19:09:13 <b_jonas> "the set of all possible execution traces" => that's so broad it allows not only nondeterminism but also semantics that can time travel
19:09:27 <b_jonas> ok, that might not be a real distinction
19:09:37 <b_jonas> general nondeterminism basically implies time travel anyway
19:09:40 <Yayimhere> korvo: simply, an expression can only either keep the length of the input, or shorten it, until it is one bit
19:09:47 <ais523> b_jonas: that's why I mentioned causality restrictions
19:09:57 <Yayimhere> which *technically* isnt what I wanted but it works fine it my case
19:11:10 <korvo> b_jonas: Lucky 10000, perhaps: There's a fairly popular state monad for Haskell that implements time travel; state can legally travel backwards from the POV of the monad's order of operations.
19:11:23 <korvo> But that might be a POV issue rather than actual time travel.
19:12:51 <korvo> Yayimhere: I think it can be beautiful in stories. You might enjoy the movie "Primer"; it's easily my favorite. There's a book on my shelf, "The Bone Clocks", that might be available in your language of choice and I think you could handle at your age.
19:13:16 <Yayimhere> korvo: in fact. Ill look into both of them
19:13:26 <ais523> I tend not to like time travel stories because they don't normally play into the nature of time travel consistently
19:13:53 <ais523> like, the stories are written as though they happen in order in time, things later in the story are caused by things earlier in the story and people have memories that extend backwards through the story's pages
19:14:15 <esolangs> [[User:Uff20xd]] N https://esolangs.org/w/index.php?oldid=168171 * Uff20xd * (+158) created the page
19:14:38 <esolangs> [[User:Uff20xd]] https://esolangs.org/w/index.php?diff=168172&oldid=168171 * Uff20xd * (+4)
19:15:20 <korvo> In computing, we generally think it's impossible due to physics. If it *were* possible then we could do a lot of cheating. For example, suppose we want to know the answer to a hard problem, and we can cycle through the possible answers with a simple counter that resets when it overflows. Then we can solve an NP-hard problem by putting the cycle machine into a time loop (a CTC or "closed timelike curve") and reading the counter afterward.
19:17:04 <korvo> ais523: I also appreciate when the work clarifies the nature of time travel somehow. "Primer" comes with a temporal model. "Hitchhiker's Guide to the Galaxy", which our younger guests might not recognize at first, contributed a little bit with verbs and thought experiments although the physics was bunk.
19:17:50 * korvo willen haven been eating breakfast
19:18:05 <ais523> korvo: HHGTTG didn't actually define those verbs though
19:18:06 <b_jonas> what? younger guests don't recognize HHGG?
19:18:08 <ais523> it just came up with a few as a joke
19:18:23 <ais523> without enough context to understand what they meant or use them in other situations
19:19:20 <Yayimhere> oh yea, ais523, to give the language I created with "infinite alphabet" see Apraxia on the esolangs wiki
19:20:01 <ais523> Yayimhere: ah, I looked at that already, it's more like an "undefined alphabet" language in that it works equally well in any language (but having more letters lets you write more complicated programs)
19:20:04 -!- pool has quit (Read error: Connection reset by peer).
19:20:28 <Yayimhere> ais523: oh, wow. But yea true, the alphabet is defined as the program executes
19:20:36 <Yayimhere> which I guess is the same as incident to some extenet
19:20:51 <ais523> well, both Apraxia and Incident can do their parsing in advance
19:21:17 <Yayimhere> anyways, I have to leave now, bye, it was nice talking!!!
19:21:19 <ais523> this is true of most languages, except for some languages with a string eval and some self-modifying langauges
19:21:22 <korvo> Couldn't find breakfast. Got some string cheese.
19:21:26 <korvo> ais523: That's fair.
19:22:07 -!- pool has joined.
19:22:37 <b_jonas> korvo: as in, most languages cheese the alphabet thing by allowing multi-character identifiers of arbitrary length and then only care about the tokens, not the original alphabet of characters, thus cheesing the restriction of finite alphabets by using strings?
19:22:40 <esolangs> [[User:Uff20xd]] https://esolangs.org/w/index.php?diff=168173&oldid=168172 * Uff20xd * (+21)
19:22:49 <esolangs> [[User:Uff20xd]] https://esolangs.org/w/index.php?diff=168174&oldid=168173 * Uff20xd * (+1)
19:22:54 <korvo> But yeah, time travel bugs me because it leads to people talking about tachyons and other ridiculous ideas. Folks get lost first in the math, then in the literary memes, and then in the emotional anguish of not being able to properly regret and find closure in the immutable past.
19:23:18 <b_jonas> and most of the time it's easier to choose spellings for the tokens than in Incident
19:23:48 <ais523> b_jonas: isn't that one of the two hard problems of computer science?
19:24:15 <korvo> b_jonas: Oh wow, that's amazing. What a thought. No, in the USA we have little prism-shaped blocks or "strings" of low-moisture mozzarella "cheese". I'm told that the mere existence of low-moisture mozzarella is a horrifying concept in Europe, but over here we often batter and deep-fry them to make "mozzarella sticks".
19:24:15 <b_jonas> if you want the code to be readable then yes
19:24:42 <ais523> korvo: it depends a lot on country, you will horrify the Italians more than the Brits
19:24:46 <b_jonas> korvo: yeah, I know that's the other meaning, and Europe has cheese strings too
19:25:10 <b_jonas> or at least string-shaped cheese
19:25:17 <ais523> from my point of view it seems highly nutritionally unbalanced and I'm not sure why people would want to eat it, but I don't recoil from it in horror the way some people would
19:26:21 <korvo> Ah, okay. No worries; I'm not judging where anybody's from, I just know that the USA's attitude toward cheese is not shared by the rest of the lactose-tolerant world. I've seen the memes. I live with somebody who eats shredded cheese out of the bag at 2 in the morning.
19:26:56 <korvo> "highly nutritionally unbalanced" is great litote for what we eat over here.
19:27:19 -!- Yayimhere has quit (Ping timeout: 250 seconds).
19:27:54 <ais523> I'm intolerant to cheese so I don't have personal experience of this sort of thing (when I was very young, before it was discovered that I couldn't safely eat it, I did enjoy cheese though)
19:30:13 * Sgeo is glad that lactase enzyme supplements exist. I survive partly on pizza and am lactose intolerant
19:30:47 <ais523> for me it isn't lactose, it's probably one of the other chemicals in milk but we're not sure which one
19:31:15 <b_jonas> korbo: as in https://www.smbc-comics.com/comic/bomb
19:33:43 <korvo> b_jonas: Ooh, yeah. Canadians are even more extreme; poutine is real and delicious.
19:36:05 <korvo> We also love imitating other cheeses. At a local burger place, I can get pepperjack, cheddar, chevre, or swiss. Lowercase on all of those, of course; we're not importing them but making them here in Oregon.
19:37:05 <korvo> Curses. I had an apple but I'm still hungry. Now I want a cheeseburger.
19:39:43 <korvo> Oh, now I remember where I'd seen Yay's type before. https://math.andrej.com/2007/09/28/seemingly-impossible-functional-programs/
19:40:35 <korvo> Imperative version, using ejectors, with comments: https://github.com/monte-language/typhon/blob/master/mast/fun/cantor.mt
19:41:20 <ais523> korvo: oh, I remember that one too! (the Escardo post)
19:41:46 <korvo> Yeah. And then he came back a few years later with this one: https://math.andrej.com/2014/05/08/seemingly-impossible-proofs/
19:48:43 <ais523> Escardo and I were actually working in the same department at the same time (but I don't think it overlapped with when he was doing this work)
19:50:23 <ais523> but I don't really understand topology to a CS-research level
19:50:50 <ais523> (the category theory was hard enough)
20:00:28 <korvo> Research-level constructive maths is really tough because, quoting Bauer IIRC?, "it requires us to unlearn all of our intuitions." It's not really as intuitive as the word "intuitionistic" would lead one to believe.
20:01:52 <korvo> Escardó had an old post, a tweet maybe, where they asked folks about trichotomy on the real numbers; constructively, given that either x = 0, x < 0, or x > 0, is x a real? The answer is "yes" in typical constructive foundations and it made me realize how much I lean on pattern-matching and bogus assumptions.
20:03:05 <korvo> ...Wait, that's a bizarre way to phrase trichotomy. I don't know why, but I don't like what I just wrote. It's probably wrong somehow.
20:04:25 <ais523> well, x=0 is obviously a real, the rest of the question depends on how you define < and > I think
20:04:58 <ais523> an esolang I'm working on has three data types (dynamically typed): complex rationals, lists, and null
20:05:50 <ais523> and in that esolang, it is the case that a value x is a real number if and only if one of x = 0, x < 0, and x > 0 is scalar true
20:06:39 <ais523> (calculating [1, 2] > 0 gives you a list of two truthy elements, which is truthy itself, but [1, 2] isn't a real number, so a "scalar true" requirement is needed not just "true")
20:26:32 <esolangs> [[Iterate/Math]] https://esolangs.org/w/index.php?diff=168175&oldid=165589 * Aadenboy * (+1413) friendlier labels
21:00:13 <zzo38> I would think that x>0 can be if x is infinite
21:02:08 <ais523> my esolang doesn't have an infinity, 1/0 is null
21:15:49 <zzo38> Another alternative of JSON-based syntax would be ASN.1-based syntax; ASN.1X is a superset of the data model of JSON (standard ASN.1 isn't because it lacks a key/value list type).
21:56:59 <zzo38> (Also, I think the JSON syntax described for Delta Relay is actually "concatenated JSON" format, from what I can understand of it. NDJSON is a subset of concatenated JSON, and I wrote a program in uxn to convert stanard JSON to concatenated JSON with line breaks in between.)
21:57:30 <zzo38> (Also, concatenated JSON does not work if any of the top-level values are numbers.)
22:18:02 <esolangs> [[User:Buckets]] M https://esolangs.org/w/index.php?diff=168176&oldid=168120 * Buckets * (+8) /* 2024 */
22:18:10 <esolangs> [[User:Buckets]] M https://esolangs.org/w/index.php?diff=168177&oldid=168176 * Buckets * (+0) /* Total of Esolangs */
22:18:46 <esolangs> [[Language list]] M https://esolangs.org/w/index.php?diff=168178&oldid=168116 * Buckets * (+9)
22:19:04 <esolangs> [[O&]] N https://esolangs.org/w/index.php?oldid=168179 * Buckets * (+2944) Created page with "{{lowercase}} o& is an Esoteric Programming Language created By [[User:Buckets]] in 2024. {| class="wikitable" |- ! Commands !! Instructions |- | / || Pushes the value of The previous Cell Value, then It Increments It by one. |- | * || Swap the Current tape Cell with The top
22:25:50 -!- tromp has joined.
22:29:22 <avih> hmmm... i wrote an infinite counter bf program:
22:29:40 <avih> ++++++++++[>>>>>----------<[>+>+<<-]>>[-<<+>>]+<[>-<[-]]>[[-]<<[-]+>>>>--
22:29:40 <avih> --------<[>+>+<<-]>>[-<<+>>]+<[>-<[-]]>]<<[>+>+<<-]>>[-<<+>>]+<[>-<[-]]>[
22:29:40 <avih> [-]<<+>>]<<+[>>>]<<<[<++++++++[>++++++<-]>-.<++++++++[>------<-]>+<<<]<.]
22:30:16 <avih> (prints decimal numbers, starting at 1, each followed by newline)
22:31:04 <avih> (that's actually my 1st bf program, other than "cat". wasted way too long on it, but it was interesting)
22:31:48 -!- Sgeo_ has joined.
22:31:52 <avih> maybe s/wasted/spent/ :)
22:35:53 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
22:36:02 -!- Bowserinator has joined.
22:36:03 <avih> _way_ too many instructions on "if (cell is 0) {set cell to 1}"
22:36:47 -!- pool4 has joined.
22:36:58 <avih> (without destructing cell if it's not 0)
22:38:06 -!- Lord_of_Life_ has joined.
22:38:42 <avih> that's my current code for that, which uses 2 tmp cells right after cell itself. if anyone has a better idea for that, i won't mind hearing:
22:38:43 <avih> [>+>+<<-]>>[-<<+>>]+<[>-<[-]]>[[-]<<
22:40:21 <avih> (it's an application of my generic "if (cell == N) BODY" where N is 0 and BODY is "+")
22:40:37 -!- lambdabot has quit (Ping timeout: 256 seconds).
22:40:38 -!- pool has quit (Ping timeout: 256 seconds).
22:40:38 -!- amby has quit (Ping timeout: 256 seconds).
22:40:38 -!- simcop2387 has quit (Ping timeout: 256 seconds).
22:40:38 -!- perlbot has quit (Read error: Connection reset by peer).
22:40:39 -!- pool4 has changed nick to pool.
22:41:03 -!- perlbot has joined.
22:41:11 -!- Lord_of_Life has quit (*.net *.split).
22:41:11 -!- Sgeo has quit (*.net *.split).
22:41:12 -!- Bowserinator_ has quit (*.net *.split).
22:41:12 -!- iovoid has quit (*.net *.split).
22:41:21 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
22:41:35 -!- simcop2387 has joined.
22:42:23 -!- lambdabot has joined.
22:43:07 <avih> s/cell/cell-value/
22:44:15 -!- ajal has joined.
22:44:15 -!- iovoid has joined.
22:44:46 -!- tromp has joined.
22:45:42 <avih> (the tmp cells are assumed 0 initially, and are already back with value 0 at BODY)
22:46:46 <int-e> There's stuff like >+<[>->]>[>>]<< which needs 3 temp cells, all initially 0, and sets the first of them to 1 if the cell is zero
22:48:10 <int-e> err, one more < to move back to the original cell
22:48:20 <avih> i don't mind 3 tmps, and i do the same with one of the temps, but "if (val == N) BODY" is more than just setting a tmp cell to 1 if the condition is true. it includes also cleanups
22:49:07 <int-e> the other two temps aren't modified, they're just used as landing pads for the loops
22:49:09 <avih> but thanks, let me check what it does. maybe i'll get ideas
22:49:41 <avih> gotcha. so only 1 tmp? and cell itself is not destructed in the process?
22:50:09 <avih> cool. let me figure out that code. thanks.
22:50:56 <avih> (i can't really read bf in my head yet...)
22:51:07 <ais523> what about [->[-]->+<<]>+
22:51:09 <int-e> they are "temporary" in the sense that they need to be 0, so you can't store useful data there
22:51:25 <avih> int-e: yeah, got that.
22:51:35 <ais523> (preserves the value but moves it to a different cell, you can move it back afterwards)
22:51:41 <avih> they need to be there as 0 at the time of this code.
22:52:39 <ais523> written like that it needs a wrapping implementation but a non-wrapping version is easy too
22:53:39 <ais523> oh, even better, set the target cell to 1, then [->[-]>+<<]
22:54:17 <avih> ais523: that's basically what my code does, including the moving back. but i need to look more carefully at these codes. i don't read it "natively"...
22:54:36 <ais523> I'm basically just translating from counter machines
22:54:48 <ais523> that isn't the only way to program in BF but it's usually one of the simplest
22:55:14 <int-e> ais523: I'm advocating unbalanced loops :P
22:55:17 <avih> not familiar with counter machines or the paradigm of such translation
22:55:52 <ais523> you can think of counter machines as being BF except all the loops are balanced
22:56:00 <avih> unbalanced loops are fine. i use them too. the right tool for the job is what matters
22:56:26 <ais523> they are normally easier to implement than BF itself is, so I frequently use them as a basis for programming in other non-BF esolangs
22:56:32 <ais523> so I'm pretty used to them and how they work
22:56:42 <avih> ais523: off the top of my head, that hardly makes my life easier in programming for THAT and then translating to bf ;)
22:57:32 <avih> but i will look at these codes. i can read bf, just not in a glance
22:58:24 <ais523> after staring at enough BF, things like [->+>+<<] sort-of become single words that you can recognise immediately
22:58:59 <avih> int-e: ais523: so with your suggestions, how would it look to "if (value == N) BODY" ?
22:59:17 <avih> (without destructing value)
22:59:22 <ais523> subtract N from the value, do an "if value == 0 BODY", add N to the value again
22:59:49 <avih> i mean in code.
23:00:14 <ais523> (the thing I find hardest when switching between Rust and C is remembering that C wants parentheses around an if condition and Rust doesn't"
23:00:18 <avih> because it _sounds_ like what my code does. but these subs and copies do end up with additional instructions.
23:01:11 <avih> i don't mind if you write c without parenthesis at the condition :)
23:01:13 <ais523> well if N is small the subtraction and addition are just strings like --- and +++
23:01:21 <ais523> avih: yes but the C compiler does
23:01:28 <avih> i''m not one...
23:01:34 <esolangs> [[Special:Log/newusers]] create * Nomnomnom * New user account
23:02:12 <avih> ais523: yes, and in the case of 0 it's even no-op, but again, it does add up at the final piece of code
23:03:50 <esolangs> [[Esolang:Introduce yourself]] M https://esolangs.org/w/index.php?diff=168180&oldid=168170 * Nomnomnom * (+25)
23:03:54 <avih> that's my generic "if (==N) BODY", where (MINUS N) is empty in the case of 0:
23:03:56 <avih> >(MINUS N)<[>+>+<<-]>>[-<<+>>]+<[>-<[-]]>[[-]<<
23:04:43 <esolangs> [[ASTLang]] https://esolangs.org/w/index.php?diff=168181&oldid=168007 * NTMDev * (+824) /* Conditionals / If Statements */
23:08:55 -!- pool0 has joined.
23:09:19 -!- pool has quit (Ping timeout: 264 seconds).
23:09:19 -!- pool0 has changed nick to pool.
23:14:41 <avih> ais523: your code starts with N 0 0 and ends up in 0 !(is N) N yes?
23:17:03 <esolangs> [[ASTLang]] https://esolangs.org/w/index.php?diff=168182&oldid=168181 * NTMDev * (+698)
23:17:27 <avih> thx. let me try to use that for my use cases. in this case BODY is simply +, but elsewhere i need the tmp cells back at 0 when BODY is executed, because BODY moves to the next digit, and it needs the tmps cleaned up when it happens
23:18:27 <esolangs> [[ASTLang]] https://esolangs.org/w/index.php?diff=168183&oldid=168182 * NTMDev * (+25) /* Conditionals (If Statements and more) */
23:18:49 <avih> (and N is not 0 currently at elsewhere)
23:19:40 <avih> (i feel like a child learning the basics of programming... weird...)
23:19:55 <esolangs> [[ASTLang]] https://esolangs.org/w/index.php?diff=168184&oldid=168183 * NTMDev * (+171) /* LogicalOperation */
23:20:12 <esolangs> [[ASTLang]] https://esolangs.org/w/index.php?diff=168185&oldid=168184 * NTMDev * (+6) /* LogicalOperation */
23:20:29 <esolangs> [[ASTLang]] https://esolangs.org/w/index.php?diff=168186&oldid=168185 * NTMDev * (+10) /* If Statement Structure */
23:20:42 <esolangs> [[Bitty]] N https://esolangs.org/w/index.php?oldid=168187 * Nomnomnom * (+109) Created page with "==Overview== bitty has 5 instructions ''!'', ''/'', ''\'', ''>'', and ''<''. the list below shows there uses."
23:33:54 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
23:34:00 <esolangs> [[Bitty]] https://esolangs.org/w/index.php?diff=168188&oldid=168187 * Nomnomnom * (+164)
23:41:11 <esolangs> [[Bitty]] https://esolangs.org/w/index.php?diff=168189&oldid=168188 * Nomnomnom * (+155) /* Overview */
23:41:32 <esolangs> [[ASTLang]] https://esolangs.org/w/index.php?diff=168190&oldid=168186 * NTMDev * (+935) /* LogicalOperation */
23:42:58 <esolangs> [[User:Nomnomnom]] N https://esolangs.org/w/index.php?oldid=168191 * Nomnomnom * (+103) Created page with "==About== i am just a user that likes esolangs, so i decided to join. ==Languages== * Bitty: [[Bitty]]"
23:44:36 <esolangs> [[Bitty]] https://esolangs.org/w/index.php?diff=168192&oldid=168189 * Nomnomnom * (+70) /* Bitty */
23:45:29 <esolangs> [[User:Nomnomnom]] https://esolangs.org/w/index.php?diff=168193&oldid=168191 * Nomnomnom * (+5) /* Languages */
23:47:17 <esolangs> [[ASTLang]] https://esolangs.org/w/index.php?diff=168194&oldid=168190 * NTMDev * (+285)
23:52:37 <esolangs> [[ASTLang]] https://esolangs.org/w/index.php?diff=168195&oldid=168194 * NTMDev * (+672) /* Switch / Match */
23:52:49 <avih> int-e: i tried to follow your code, but i'm not sure it works. 1st, your corrected code is >+<[>->]>[>>]<<< yes? if yes, then if the initial val is not 0, i think it ends up two cells left to the original cell
23:53:21 <avih> (and if it's 0 then it does end up at the original cell)
23:54:12 <int-e> if the initial value is not 0, the first loop is executed, once.
23:54:21 <int-e> otherwise, the second loop is executed once
23:54:54 <int-e> and both of these move the pointer two places to the right
23:55:15 <avih> let me look at it again. thanks.
23:57:53 <esolangs> [[ASTLang]] https://esolangs.org/w/index.php?diff=168196&oldid=168195 * NTMDev * (+162) /* Switch / Match */
23:58:22 <esolangs> [[ASTLang]] https://esolangs.org/w/index.php?diff=168197&oldid=168196 * NTMDev * (+28) /* Conditionals (If Statements and more) */