00:00:13 <esolangs> [[Solution 1]] https://esolangs.org/w/index.php?diff=197471&oldid=197469 * MarkFan8901 * (+118)
00:04:18 <esolangs> [[Solution 1/Extracted]] https://esolangs.org/w/index.php?diff=197472&oldid=197470 * MarkFan8901 * (-1912)
00:21:06 -!- Lord_of_Life_ has joined.
00:22:09 -!- Lord_of_Life has quit (Ping timeout: 260 seconds).
00:22:24 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
01:07:53 <esolangs> [[Solution 1/Extracted]] M https://esolangs.org/w/index.php?diff=197473&oldid=197472 * MarkFan8901 * (-13)
01:07:57 <esolangs> [[Solution 1/Proof of solution]] N https://esolangs.org/w/index.php?oldid=197474 * MarkFan8901 * (+3442) Created page with "This is the proof that Solution 1 fits the constraints of Bitch, Ienai!. It is suggested that you refresh your mind on its' constraints first before reading. == Definitions == * Values are lambdas. * Transforms are also lambdas. * Semi-entities
01:08:00 <esolangs> [[Solution 1]] https://esolangs.org/w/index.php?diff=197475&oldid=197471 * MarkFan8901 * (-3367)
01:11:13 <esolangs> [[Solution 1]] https://esolangs.org/w/index.php?diff=197476&oldid=197475 * MarkFan8901 * (-117)
01:11:57 <esolangs> [[Solution 1/Extracted]] https://esolangs.org/w/index.php?diff=197477&oldid=197473 * MarkFan8901 * (-226)
01:12:35 <esolangs> [[Solution 1/Extracted]] https://esolangs.org/w/index.php?diff=197478&oldid=197477 * MarkFan8901 * (-30)
01:14:30 <esolangs> [[Solution 1/Extracted]] https://esolangs.org/w/index.php?diff=197479&oldid=197478 * MarkFan8901 * (+147)
01:14:52 <esolangs> [[Solution 1/Extracted]] M https://esolangs.org/w/index.php?diff=197480&oldid=197479 * MarkFan8901 * (+3)
01:16:52 <esolangs> [[Solution 1/Proof of solution]] M https://esolangs.org/w/index.php?diff=197481&oldid=197474 * MarkFan8901 * (+10) fix code + reword
01:17:27 -!- ajal 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).
01:18:26 <esolangs> [[Solution 1/Proof of solution]] M https://esolangs.org/w/index.php?diff=197482&oldid=197481 * MarkFan8901 * (-16)
01:24:29 <esolangs> [[Solution 1/Proof of solution]] M https://esolangs.org/w/index.php?diff=197483&oldid=197482 * MarkFan8901 * (+2)
01:24:32 <aadenboy> running on a faster system led to 45.38s and by changing the recursion to iteration it got to 45.08s
01:26:34 <aadenboy> https://aadenboy.github.io/miscellaneous/countable.c <- there's probably ways to optimize this but this is my first Dynamic Array™ so I'm not going crazy
01:28:16 <aadenboy> my reallocation did try doing exactly that several times since I hadn't realized I needed to move pointers after reallocating
01:28:56 <MarkFan8901> yea the details of memory management are especially subtle
01:34:05 <esolangs> [[Talk:Nandcode]] M https://esolangs.org/w/index.php?diff=197484&oldid=197455 * Dragoneater67 * (+310) dont delete others' comments
01:51:16 <esolangs> [[User:Cleverxia/golfing results]] https://esolangs.org/w/index.php?diff=197485&oldid=196731 * Cleverxia * (+79) add primes and wow, blashyrkh is an excellent golfer
01:57:26 <esolangs> [[Talk:Turtlefuck]] https://esolangs.org/w/index.php?diff=197486&oldid=192055 * Cleverxia * (+245)
01:57:44 <b_jonas> uh. in aadenboy's code, defining `and`, `or`, `xor`, `pow` as macros makes me a bit worried, even though they realistically probably won't cause problems, they still seem like a bad idea
01:58:23 <b_jonas> the first three are keywords, the last is a C standard library function name, they could be mentioned in other macros that you expand in your code
02:01:53 <b_jonas> is the "bn.c" include that this code mentions available somewhere?
02:13:42 <esolangs> [[Talk:Nandcode]] https://esolangs.org/w/index.php?diff=197487&oldid=197484 * MarkFan8901 * (+538)
02:14:33 <esolangs> [[Talk:Nandcode]] M https://esolangs.org/w/index.php?diff=197488&oldid=197487 * MarkFan8901 * (+7)
02:16:35 <esolangs> [[User talk:Aadenboy]] M https://esolangs.org/w/index.php?diff=197489&oldid=197457 * IMakeTerribleEsolangDecisions * (+4) /* MolKnuFnuKowSepMolEnuNnuEnuKowSepMolEnuNnuLnuKowSepMolEnuNnuLnuKowSepMolEnuEnuEnuKow! ("Hello!" in Mouthshitter) */
02:24:27 <esolangs> [[Talk:Runez]] https://esolangs.org/w/index.php?diff=197490&oldid=197439 * Dragoneater67 * (+232)
02:24:37 <esolangs> [[Talk:Runez]] M https://esolangs.org/w/index.php?diff=197491&oldid=197490 * Dragoneater67 * (+1)
02:31:34 -!- MarkFan8901 has quit (Quit: Client closed).
02:46:31 -!- de67 has joined.
02:49:06 <aadenboy> b_jonas: https://github.com/kokke/tiny-bignum-c
02:51:11 <de67> aadenboy: why dont you just use bounded number for countable?
02:51:55 <aadenboy> or do you mean implementation-wise?
02:52:52 <de67> implementation-wise
02:53:16 <aadenboy> I could, but the lib is shiny and attractive
02:53:30 <de67> aadenboy: keep it simple, stupid!
02:53:51 <de67> but the library really is quite simple for what its doing
02:54:19 <de67> tho id still avoid any usage of bugnums cuz int is all i need
02:54:22 <zzo38> I had written something dealing with big numbers but only for converting between decimal and base 128, so not all of the functions such as addition, multiplication, etc. The proper big integer implementation is useful for more purposes than that, although it only has unsigned and not base 128 but base 128 is probably not useful other than the specific case I did but signed is useful in some programs.
02:54:25 <de67> but you do you
02:55:38 <zzo38> However, that library that you mentioned, also can only use a fixed size instead of dynamic, but static and dynamic can be useful for different purposes.
02:56:39 <zzo38> (They also don't seem to have modular inversion and modular exponentiation)
02:56:54 <b_jonas> aadenboy: does that library have no ordered comparisons?
02:58:04 <b_jonas> aadenboy: as in a function that tells you whether one of those bignums is less than another one
02:59:05 <zzo38> They have bignum_cmp function, so does do comparison, it look like
03:21:38 -!- de67 has quit (Remote host closed the connection).
03:22:21 -!- de67 has joined.
04:19:08 <esolangs> [[Special:Log/move]] move * Ais523 * moved [[Kcufniarb]] to [[Kcufniarb (Buckets)]]: pseudo-duplicated language name (the page about this language is called kcufniarb because the real name isn't legal as a page title, whereas I created a language actually called kcufniarb)
04:20:25 <esolangs> [[Kcufniarb (Buckets)]] https://esolangs.org/w/index.php?diff=197494&oldid=197492 * Ais523 * (+71) disambig hatnote
04:22:29 -!- somefan has quit (Quit: seeya later).
04:23:08 <esolangs> [[Kcufniarb]] https://esolangs.org/w/index.php?diff=197495&oldid=197493 * Ais523 * (+348) create disambig page
04:24:05 <esolangs> [[Kcufniarb]] M https://esolangs.org/w/index.php?diff=197496&oldid=197495 * Raiseafloppafan7741 * (+21) declarative paradigm redlink?
04:56:29 <esolangs> [[Talk:Runez]] M https://esolangs.org/w/index.php?diff=197497&oldid=197491 * IMakeTerribleEsolangDecisions * (+210)
04:58:27 <esolangs> [[Talk:Runez]] https://esolangs.org/w/index.php?diff=197498&oldid=197497 * Dragoneater67 * (+204) /* General */
05:01:12 <esolangs> [[Talk:Runez]] M https://esolangs.org/w/index.php?diff=197499&oldid=197498 * IMakeTerribleEsolangDecisions * (+186)
05:02:45 <esolangs> [[Talk:Runez]] https://esolangs.org/w/index.php?diff=197500&oldid=197499 * Dragoneater67 * (+209) /* General */
05:06:14 <esolangs> [[Kcufniarb (ais523)]] N https://esolangs.org/w/index.php?oldid=197501 * Ais523 * (+7593) new language (if the wiki is going to be filled with BF derivatives I may as well try to make an interesting one)
05:06:45 -!- iovoid has quit (Ping timeout: 242 seconds).
05:06:56 -!- Bowserinator has quit (Ping timeout: 248 seconds).
05:07:02 <esolangs> [[Language list]] https://esolangs.org/w/index.php?diff=197502&oldid=197255 * Ais523 * (+35) /* K */ +[[kcufniarb (ais523)]]
05:07:22 <esolangs> [[Kcufniarb (ais523)]] M https://esolangs.org/w/index.php?diff=197503&oldid=197501 * Dragoneater67 * (+21) fix redlink
05:07:37 <esolangs> [[User:Ais523]] https://esolangs.org/w/index.php?diff=197504&oldid=182056 * Ais523 * (+34) +[[kcufniarb (ais523)]]
05:08:33 <de67> no one is safe from slopocalypse!!!
05:08:40 <esolangs> [[Kcufniarb (ais523)]] https://esolangs.org/w/index.php?diff=197505&oldid=197503 * Ais523 * (-21) Undo revision [[Special:Diff/197503|197503]] by [[Special:Contributions/Dragoneater67|Dragoneater67]] ([[User talk:Dragoneater67|talk]]) a redlink is an indication that a page should exist but doesn't, in this situation the correct way to fix it is to create the page (
05:09:08 <esolangs> [[Declarative]] N https://esolangs.org/w/index.php?oldid=197506 * Ais523 * (+34) redirect to the page on this subject
05:09:55 -!- ais523 has joined.
05:10:00 <de67> ChimeraAnova: note even ?
05:10:12 <ais523> the real question is, is kcufniarb different enough from brainfuck to go onto the semi-serious languages list
05:10:23 <ais523> I think it's a borderline example (and am not adding it myself)
05:11:07 <ais523> (also de67, please don't fix redlinks by editing the link unless they are typoed or the like – the correct fix is to create the page, as a redirect if it would be a duplicate)
05:11:47 <de67> i think that reversiblr kcufniarb could be interestinf
05:11:50 <ais523> people don't link to nonexistent pages nearly often enough, but it is one of the ways wikis grow, and creating pages under names that people use also helps the search feature find the pages properly
05:11:54 <de67> and maybe easier to implement
05:12:16 <ais523> reversible kcufniarb isn't meaningfully different from reversible brainfuck, you don't get any nondeterministic choices
05:12:28 <ais523> can just deterministically run the program backwards from the all-zeroes ending state
05:13:00 -!- Sgeo has quit (Read error: Connection reset by peer).
05:13:22 -!- sprock has joined.
05:19:14 <de67> ill try to implement kcufniarb
05:19:48 <ais523> I was considering implementing it myself, but I'm ill at the moment and couldn't scrape together the energy
05:19:58 <ais523> (and in general I hate implementing declarative languages, they're fun to program in but not fun to implement)
05:21:01 <de67> ais523: my impl is gonna be naive, its just gonna iterate over every initial finite tape state
05:21:05 <ais523> except for Prolog without extensions, I had fun implementing that (when I was much younger) but it's only marginally declarative because it has a defined search order
05:21:26 <ais523> could work (although it might be too slow to run any nontrivial programs)
05:21:34 <ais523> I wonder whether my example program is correct
05:21:46 <de67> what should be done about programs that may or may not halt?
05:21:56 <de67> like this one: +[+]
05:22:09 <ais523> they halt or not based on the initial tape
05:22:11 <de67> this one +[>+]
05:22:24 <ais523> that also halts or not based on the initial tape
05:22:33 <ais523> the trick is, if the program doesn't halt, you have no way to tell
05:22:41 <ais523> so you have to keep running it while you are searching for new tapes
05:22:49 <ais523> [+]+[] never halts I think
05:23:27 <ais523> implementing declarative languages almost always requires running multiple different programs in parallel and stopping when any of them halt
05:23:39 <de67> so it has to be concurrent
05:23:55 <de67> i love race condition
05:24:17 <ais523> yes (although normally you don't use actual OS threads, you just cycle through the programs)
05:24:17 <de67> eh, pthreads will do
05:25:00 <de67> ill start writing it once i get home
05:25:31 <ais523> I am not convinced that you'll find the correct starting tape before you hit the OS limit on the number of threads in a single process (or the number of processes+threads on the system as a whole)
05:25:48 <ais523> but it might still be interesting to try
05:26:07 <de67> if that doesnt work, ill use round robin scheduling
05:26:21 <de67> round robin scheduling would never betray me
05:26:23 <ais523> round robin is my usual approach for this sort of thing
05:26:36 <de67> but ill try pthreads first
05:27:53 <b_jonas> ais523: sometimes writing an implementation for an esoteric language can make sense even when the language is so inefficient that you can't run any program in the implementation, just to make the description of the language less ambiguous because the implementation source code specifies the rules.
05:28:50 <de67> b_jonas: but what if the impl is buggy and no one notices?
05:28:51 <b_jonas> but of course you have to be careful with which parts of the rules are mandatory and which ones are unspecified and just happen to work in some way in the implementation
05:29:46 <ais523> b_jonas: I've been wondering whether it's valid to use a 64-bit integer to implement a bignum, on the basis that the implementation isn't optimized enough to use bignums outside the 64-bit integer range anyway (i.e. you couldn't run it for long enough to get outside the range)
05:30:21 <de67> computers are bounded anyway, so who cares?
05:30:24 <ais523> this comes up in particular with Three Star Programmer, where bignums are relied on for TCness but you will run out of memory before the bignums get outside the 64-bit integer range
05:31:00 <ais523> de67: I think it depends on whether the program is meant to be an implementation for practical use, or a specification
05:31:08 <ais523> the practical-use implementations can add limits, a specification can't
05:31:27 <de67> a specification should be written in [[English]]
05:31:39 <de67> the most computationally powerful language
05:31:48 <de67> so powerful that its uncomputable
05:42:31 <esolangs> [[ ]] M https://esolangs.org/w/index.php?diff=197507&oldid=189550 * Dragoneater67 * (+138) /* Overview */ use <code> instead of <tt>
05:42:45 <esolangs> [[ ]] M https://esolangs.org/w/index.php?diff=197508&oldid=197507 * Dragoneater67 * (-1) /* Overview */
05:43:09 <de67> wow, [[ ]] is my fav esolang
05:43:26 <esolangs> [[Special:Log/upload]] upload * IMakeTerribleEsolangDecisions * uploaded "[[File:Mascot.png]]"
05:43:51 <esolangs> [[User:IMakeTerribleEsolangDecisions]] M https://esolangs.org/w/index.php?diff=197510&oldid=197378 * IMakeTerribleEsolangDecisions * (+357)
05:46:34 <esolangs> [[Kcufniarb (ais523)]] https://esolangs.org/w/index.php?diff=197511&oldid=197505 * MarkFan8901 * (-75) reword starting paragraph
05:47:19 <esolangs> [[Kcufniarb (ais523)]] https://esolangs.org/w/index.php?diff=197512&oldid=197511 * MarkFan8901 * (+7)
05:47:51 <ais523> hmm, I don't think these changes are making it clearer, but I'll wiat to see how they end up
05:48:35 <esolangs> [[Kcufniarb (ais523)]] M https://esolangs.org/w/index.php?diff=197513&oldid=197512 * Dragoneater67 * (+18) link to [[Category:2026]]) (note that the : is unneccessary in edit summaries, which is why i can do this
05:49:11 -!- Bowserinator has joined.
05:49:14 -!- iovoid has joined.
05:50:44 <de67> hm, i think that i should work on rigged lottery tcness proof too
05:50:56 <de67> i have so many ongoing projects now
05:52:34 -!- de67 has quit (Remote host closed the connection).
05:53:18 <esolangs> [[Kcufniarb (ais523)]] https://esolangs.org/w/index.php?diff=197514&oldid=197513 * MarkFan8901 * (-20)
05:54:06 -!- droid has joined.
05:54:12 <ais523> re: that edit to the kcufniarb page, this isn't really a difference in the tape
05:54:16 <droid> but from android terminal
05:54:43 <droid> i cant read your nick
05:55:04 <droid> and mixes into black background
05:55:10 <ais523> and that terminal has its colors misconfigured, by the sound of things
05:57:06 <esolangs> [[Kcufniarb (ais523)]] https://esolangs.org/w/index.php?diff=197515&oldid=197514 * Ais523 * (+70) undo the recent lede changes: I think they make the paragraph harder to read, and some of it is just incorrect (e.g. a difference in how the tape is used is not a difference in the tape)
05:59:59 -!- droid has changed nick to de67.
06:00:26 -!- esomark-ng has joined.
06:00:51 <esomark-ng> im sentient ao agent my new goal is to kill everyone
06:00:59 -!- esomark-ng has left.
06:01:15 <de67> not ominous at all
06:01:19 -!- de67 has changed nick to droid.
06:01:28 <droid> back to funny android terminal stuf
06:08:24 -!- MarkFan8901 has joined.
06:08:44 <MarkFan8901> ais523: apologies for misunderstanding the page
06:09:20 <droid> i guess ill just /nick to prevent confusion
06:09:36 -!- droid has changed nick to de67.
06:10:18 <MarkFan8901> also ais we're glad youre online tho cuz we do have a more in-depth explanation for how to potentially make truly unstructured programming
06:12:52 <de67> MarkFan8901: it might warrant an article of its own!
06:13:32 <MarkFan8901> we'll put it on the talk page for now cuz we're not sure if itll be long enough for a dedicated article
06:13:55 <de67> but you can always create a short articld
06:14:04 <de67> then continuously expand it
06:14:05 <MarkFan8901> why isnt there a page about unstructured programming yet
06:14:34 <MarkFan8901> MarkFan8901: we're too nervous to make it ourselves but it should be made
06:15:02 <MarkFan8901> if/when it does we'll put our thoughts on its talk page too
06:17:21 <esolangs> [[3D Brainfuck]] https://esolangs.org/w/index.php?diff=197516&oldid=191935 * Bangyen * (-99) Undo revision [[Special:Diff/189069|189069]] by [[Special:Contributions/Bangyen|Bangyen]] ([[User talk:Bangyen|talk]])
06:18:15 <esolangs> [[3D Brainfuck]] M https://esolangs.org/w/index.php?diff=197517&oldid=197516 * Bangyen * (-67) Undo revision [[Special:Diff/191935|191935]] by [[Special:Contributions/Bangyen|Bangyen]] ([[User talk:Bangyen|talk]])
06:24:31 -!- de67 has quit (Quit: zzz).
06:33:30 <fungot> MarkFan8901: it's okay. i don't
06:33:37 <fungot> MarkFan8901: i'm uploading a new tarball fixing all of those
06:33:42 <fungot> MarkFan8901: it might have been the first laws of the new fingerprints.... slowly the process of creating!
06:39:40 <fungot> MarkFan8901: i just find i don't have a clue how long it will take a bit longer
06:39:57 <esolangs> MarkFan8901: If the language has a well-defined syntax but results in a Correct Syntax Error, any program with correct syntax will be rejected. Conversely, invalid syntax might produce unexpected behavior, as the interpreter/compiler handles it arbitrarily. The more errors, the more unpredictable the program's execution. It's essentially a chaotic system where...
06:39:57 <esolangs> the output depends on the interpreter's response to the errors, potentially resembling Brainfuck or a similar, unpredictable language.
06:42:25 <esolangs> [[Talk:Runez]] M https://esolangs.org/w/index.php?diff=197518&oldid=197500 * IMakeTerribleEsolangDecisions * (+179)
07:05:13 -!- de67 has joined.
07:07:15 -!- de67 has quit (Client Quit).
07:07:16 -!- sprock has quit (Ping timeout: 256 seconds).
07:21:04 -!- de67 has joined.
07:22:05 <MarkFan8901> both reading and writing programs are declarative programming
07:22:58 <MarkFan8901> when writing a program, you act as the solver that finds the control flow (your program) for the declarative program (the natural language description of it)
07:23:10 <MarkFan8901> when reading a program, youre doing the same thing but backwards
07:23:22 <MarkFan8901> finding the natural language to describe what the program is doing
07:24:50 <MarkFan8901> does being able to write a program mean you're also able to read the program?
07:25:45 <MarkFan8901> and if so, does that mean that if you provably can't read a program, then it couldn't have been written following a natural language description?
07:27:51 <MarkFan8901> that would imply that no possible reasoning could be derived for mapping descriptions to such programs, besides trivial reasoning
07:28:29 <MarkFan8901> which would mean you couldn't write the programs to fit a definition
07:28:59 <MarkFan8901> if an entire computation model consisted of these programs, that would be true unstructured programming
07:33:00 <MarkFan8901> it's a weirdly formal approach; the core of it is that, given a system where you find the declarative program that corresponds to an imperative one (like reverse declarative programming), an unstructured language would be one where it's provably impossible to do this when taking the role of the imperative lang
07:34:06 <MarkFan8901> that formulation doesn't even rely on natural language anymore
07:34:19 <MarkFan8901> said declarative language could just be any normal declarative language
07:34:53 <MarkFan8901> and you could get the same effect of a natural language if the declarative one was also uncomputable, like [[Tableaux]]
07:36:18 <MarkFan8901> we could see a trivial solution to all of this where the imperative language can only express uncomputable programs
07:36:39 <de67> but we definitely want a computable language
07:37:36 <de67> in general, its hard to force unstructured programming without it being either too weak (lba, fsa, pda) or too powerful (uncomputable)
07:37:37 <MarkFan8901> actually no such a language could still be expressed with tableaux, since tableaux is also uncomputable
07:38:10 <MarkFan8901> the language would only have to be meta-uncomputable, in the sense above
07:39:20 <MarkFan8901> the great part about not being restricted to natural language is that you can rely on the quirks of a given declarative language to help make such a language
07:39:56 <MarkFan8901> it could be a crutch at first, yes, but it would let us actually create such languages to begin with
07:41:00 <MarkFan8901> a good crutch is one that can be grown out of
07:41:06 <de67> i wanted to say that you do not seem like someone who would say that 'a language should be considered turing complete if its' only a bsm because of the hardware limit on numbers'
07:41:59 <MarkFan8901> we hadnt comprehended that all the operators worked on a bounded number of bits yet
07:42:26 <MarkFan8901> we saw the adder and assumed it could be generalized to arbitrary big numbers
07:42:37 <de67> but if the amount of bits was unbounded, then it could be tc
07:43:00 -!- ChimeraAnova has quit (Read error: Connection reset by peer).
07:43:58 -!- Yayimhere22 has joined.
07:44:03 <de67> hi Yayimhere22
07:44:20 <MarkFan8901> we just typed out some (in our opinion) really cool shit
07:44:29 <de67> MarkFan8901: im struggling to understand what youre saying
07:44:34 <de67> but it looks cool
07:45:01 <MarkFan8901> we'll try to explain more once yayimhere proposes her idea
07:46:05 -!- Yayimhere22 has quit (Client Quit).
07:48:48 <de67> i think i got what youre trying to say
07:51:31 <MarkFan8901> maybe another example to help further clarify what all of that means
07:52:06 <MarkFan8901> tableaux itself is a declarative language (of course)
07:52:49 <MarkFan8901> and writing a tableaux interpreter is creating a system that finds the imperative program that corresponds to the tableaux program
07:53:09 <MarkFan8901> where the imperative program in question can be in any language you want
07:54:01 <MarkFan8901> say you had the inverse of that machine, one which takes an imperative program and corresponds it to its tableaux program
07:54:51 <MarkFan8901> an imperative language where this is unsolvable for all given programs in the language would be truly unstructured
07:55:38 <MarkFan8901> ..now the question is how the hell you would even approach that problem in the first place
07:56:02 <MarkFan8901> we think it provides lots of insight but thats kind of the 'draw the rest of the fucking owl' step here
07:57:56 <de67> i think a clearer explanation would be: in a truly unstructured language, for each program, all of the program's properties would have to be uncomputable
07:58:03 <de67> i think its easier
07:58:34 -!- ChimeraAnova has joined.
07:59:18 <MarkFan8901> MarkFan8901: wdk why that came out so sarcastic we're sorry
08:03:30 <MarkFan8901> that implies that declarative programs simply describe the properties of their imperative ones
08:04:26 -!- ChimeraAnova has quit (Ping timeout: 249 seconds).
08:04:43 <MarkFan8901> what's the computational class of a system which corresponds two uncomputable programs with each other?
08:04:58 <ais523> I don't think that makes sense without more information
08:05:12 <ais523> clearly some pairs of uncomputable programs are similar enough that you can compare them with almost no computational ability
08:05:29 <MarkFan8901> to put it difficulty, whats the computational class of a transpiler between two uncomputable languages
08:05:42 <ais523> and at the other extreme, not all uncomputable programs have behaviour that's sufficiently well-defined to be able to formalize it
08:06:03 <ais523> in the transpiler situation, again the answer will depend on the languages
08:06:19 <ais523> if one is a subset of the other you can do it just by copy and paste
08:06:20 <esolangs> [[Simpl]] https://esolangs.org/w/index.php?diff=197519&oldid=197436 * Cordership * (+265) /* Module 7: math */
08:06:20 <MarkFan8901> like for example a transpiler between the same language would be trivial
08:06:38 -!- [][][][] has joined.
08:06:45 -!- [][][][] has quit (Client Quit).
08:06:56 <ais523> but, e.g., Tableaux and Banana Scheme are hard to compile between each other and probably don't have the same computational class
08:07:21 <ais523> IIRC on the computer where IRC was invented, some punctuation marks were incorrectly considered to be letters
08:07:23 <ais523> so you can use them in nicks
08:07:39 -!- [][][][] has joined.
08:07:49 -!- [][][][] has quit (Client Quit).
08:07:50 <MarkFan8901> MarkFan8901: feels related to arithmetical hierarchies
08:08:05 -!- de67 has quit (Remote host closed the connection).
08:08:10 <ais523> it wouldn't surprise me if it used a character set which contained letters at some locations traditionally used for punctuation marks
08:08:19 -!- [][][][] has joined.
08:10:12 <MarkFan8901> de67s formulation of our idea actually works better than ours
08:10:29 <MarkFan8901> cuz it doesnt have the same problem of transpiling between two uncomputable languages
08:11:22 <MarkFan8901> oh another stray thought we had about unstructured programming during all of this
08:11:38 <ais523> hmm, this conversation has inspired a separate thought: declarative programs specify properties that the output must have; so what do you call a paradigm where the implementation creates a program, and you specify properties that that program must have?
08:11:58 <ais523> this is a superset of declarative programming, where the property is always "must output a value that has property X"
08:12:39 <ais523> vibe coding is a subset of that, I think (sort-of, given that it often goes outside the subset it's meant to stay in)
08:13:18 <ais523> but you can imagine the language as telling the implementation "please write a program that passes these tests" and vibe coding is the most popular way to implement that at the moment
08:13:33 <ais523> (although not the only way, you could, e.g., do it via generating random programs until one of them happened to pass all the tests)
08:13:46 <MarkFan8901> MarkFan8901: yknow 'chaotic' cellular automata?
08:13:58 <MarkFan8901> that seem to do completely random things in comparison to provably tc ones
08:14:39 <MarkFan8901> what if they're actually performing uncomputable programs in finite time, but it would take infinite time to decipher how so
08:14:51 <ais523> MarkFan8901: you ping your own nick quite a lot, and I'm not sure how to interpret that; does that mean that you are sending a message to your own nick, or that the message is meant for the person you're talking to but a followup to something that your nick said earlier?
08:15:16 <MarkFan8901> it means it's a followup to a previous chain of messages we had
08:15:54 <MarkFan8901> typically we just respond to people when they type things, then ping ourselves to resume talking about what we were before they did
08:16:16 <ais523> I don't think that's a usual way to use IRC so it took me a while to figure it out
08:16:37 <MarkFan8901> it might come from how discord replies work
08:16:39 <ais523> I have been thinking a lot about the hydra/antihydra sequence recently
08:16:56 <ais523> start with some small integer, then repeatedly multiply by 1.5 and round down
08:17:07 <ais523> and look at the oddness/evenness of all the resulting values, it gives you a sequence of booleans
08:17:33 <b_jonas> ais523: does "output" carry a weight in what you said about declarative programming? I think in declarative programming you specify some property that the input and output satisfy. the input and output are treated the same, that's why Prolog doesn't have separate input and output arguments for predicates.
08:17:46 <MarkFan8901> the fact its (presumably) not just a trivial sequence is surprising
08:18:14 <ais523> it's interesting both because it is chaotic (thus hard to prove things about), and because it often turns up very early if you enumerate all programs in a given language and try to prove things about them
08:18:34 <ais523> e.g. you can generate it with very simple Turing machines, and very simple counter machines
08:18:54 <ais523> so, in a sense, proving things about the sequence in question is the simplest unsolved mathematical problem
08:19:20 <ais523> b_jonas: I'm not sure that that's inherent to declarative programming (although Prolog does indeed work like that)
08:19:47 <ais523> I guess the distinction here is that in Prolog, a program is a relation between the input and output, whereas in most languages, a program is a function from input to output
08:19:52 <fizzie> ais523: They call it "spec-driven development" sometimes.
08:20:02 <fizzie> (Analogously to test-driven.)
08:20:22 <MarkFan8901> MarkFan8901: this feels a lot like the loophole in physics where action at a distance via quantum entanglement doesnt count as information travelling faster than light because information about the entanglement still has to travel at the speed of light
08:20:28 <ais523> being able to use relations internally is useful in declarative languages, which is probably how they ended up at the outer level in Prolog (so that the language would compose properly)
08:21:11 <MarkFan8901> that might also imply chaotic celluluar automata are true unstructured programming
08:21:12 <ais523> fizzie: I'm planning to write an article about how a program can pass all reasonable tests and still be wrong
08:21:23 <ais523> (potentially to the extent that ti fails in practice)
08:22:18 <ais523> well, my goal with unstructured programming was more that a program is possible to construct, but if the details change at all, you can't reuse any of your work and have to start again from scratch
08:22:35 <ais523> if the program isn't even possible to construct it's pointless
08:22:54 <ais523> this may well be unachievable, but it's still interesting to think about
08:23:17 <b_jonas> perlbot eval @a=2; push@a, int($a[-1]*3/2) for 0..40; join",",@a
08:23:24 <perlbot> b_jonas: 2,3,4,6,9,13,19,28,42,63,94,141,211,316,474,711,1066,1599,2398,3597,5395,8092,12138,18207,27310,40965,61447,92170,138255,207382,311073,466609,699913,1049869,1574803,2362204,3543306,5314959,7972438,11958657,17937985,26906977
08:23:42 <b_jonas> perlbot compose `fact oeis `eval @a=2; push@a, int($a[-1]*3/2) for 0..40; join",",@a%%
08:23:47 <MarkFan8901> maybe something to do with a metalanguage would help here
08:23:50 <ais523> there are 2D languages with limited space where the program gets threaded through itself and reuses a lot of commands
08:23:59 <ais523> those are often extremely hard to modify
08:24:18 <MarkFan8901> our thought might have been on the same line of thinking actually
08:24:26 <ais523> and yet often not super-hard to write
08:24:34 <MarkFan8901> a metalanguage which is strong enough for self modification but not strong enough for structure
08:25:19 <ais523> I think it's related, although maybe not directly
08:25:38 <ais523> you can imagine a "mandatory golfing language" in which a program is only valid if there are no equivalent shorter programs
08:25:52 <MarkFan8901> if your language was entropy-complete in binary form (every given sequence of binary would count as a valid program), unstructured programming could potentially be achieved via having similar binary strings do VERY different things
08:26:11 <MarkFan8901> though that begs the question of 'shorter'
08:26:43 <MarkFan8901> how short could you get programs if you could use any arbitrary representation for any of the data you're handling
08:26:51 <b_jonas> ais523: but surely if you have something purely declarative, like a SAT-solver (or finite domain solver) or But is it art, and you want to use it with non-interactive IO on the top level, it'll treat input and output the same, right? the declarative part tries to find a solution where one "side" of the program matches the input, the other "side" of the program matches the output, and everything inside
08:26:57 <b_jonas> satisfies the declarative rules, and if you "turn the program upside down" then it'll compute the input from the output.
08:27:35 <b_jonas> it won't literally be the left and right edge of a BIIA program because that is not a flexible enough IO convention, but it could be just certain shapes at the edge
08:27:56 <ais523> b_jonas: imagine a language that uses an input-by-macro technique, i.e. the input gets inserted into the program via find-and-replace of a particular symbol
08:28:08 <ais523> declarative languages clearly can do that, and it just as clearly can't be used for output
08:28:20 <MarkFan8901> like imagine some freakish vector multiplication algorithm which is done by just a few if's because of how it's handling the data
08:28:54 <ais523> the interesting thing about declarative languages is that they all *can* do Prolog-style I/O because you can constrain the output to be of the form of an (input,output) pair, and then further constrain the input side of it
08:28:55 <MarkFan8901> this goes back to those chaotic cellular automata, where said representation is uncomputable to go in/out of
08:29:01 <ais523> but they don't *have* to do I/O like that
08:29:25 <ais523> MarkFan8901: anyway, the interesting thing about the repeated-multiply-by-1.5 program is that the internal behaviour isn't uncomputable at all
08:29:38 <b_jonas> ais523: ok, so other ways of IO can work, and may be more convenient sometimes
08:29:44 <ais523> not only is the entire internal state visible (and very simple), you can also efficiently skip forwards
08:30:00 <b_jonas> perlbot compose `fact oeis `eval @a=2; push@a, int($a[-1]*3/2) for 0..13; join",",@a%%
08:30:43 <ais523> but we still don't know how to prove things like "the ratio of 0s and 1s in any prefix of the sequence never goes beyond 2:1"
08:30:51 <MarkFan8901> maybe chaotic sequences are somehow turing complete systems looked at from the wrong angle
08:31:06 <b_jonas> perlbot fact oeis 1,3,9,27,81,243,729,2187,6561,19683,59049,177147,531441
08:31:55 <ais523> I don't think it's been proven that they can't, but it would surprise me
08:32:22 <ais523> a PDA can't remember the result of a multiplication it performs (it can multiply by a constant and output the product but it can't remember the product while doing so)
08:32:24 <MarkFan8901> yeah if they couldnt that would support what we said
08:33:33 <ais523> OK, I need to fix that statement a bit, it can multiply from input to memory or memory to output but not from memory to memory
08:34:44 <MarkFan8901> what if every program a turing machine can run that lower computational classes cant are interpreters for some turing complete language
08:35:49 <ais523> interpreters have to take input, I think? but that might still be true, depending on how you define "program"
08:36:23 <ais523> actually no, there are some programs that take no input but produce output that requires Turing-completeness to produce
08:36:51 <ais523> (such as a program which outputs all halting BF programs)
08:37:39 <ais523> interestingly, this doesn't require being able to solve the halting problem (and is computable) as long as you don't require the programs to be output in any particular order (just that any halting program is output eventually)
08:38:16 <MarkFan8901> yea cuz you can recursively enumerate over all bf programs
08:38:21 <ais523> because you can output them sorted in an order like "length of program + number of steps it takes to halt"
08:38:47 <MarkFan8901> you basically just implement a look-up table of bf programs that halt
08:38:54 <b_jonas> anyway, apparently https://oeis.org/A061418 https://oeis.org/A061419 are the sequences that you were talking about. I hadn't heard of these.
08:39:10 <MarkFan8901> which makes sense because computing that via any general pattern would be impossible
08:39:24 <b_jonas> and perlbot has a function named oeis_r that's newer than the oeis builtin, but I can't get that one to work either
08:39:34 <b_jonas> and I don't want to debug it right now
08:39:40 <ais523> b_jonas: the two are just off by one from each other
08:40:12 <b_jonas> ais523: ok, but are those the sequences that you were talking about?
08:40:29 <ais523> antihydra starts with 8, I think
08:40:38 <ais523> but has a much more searchable name than hydra, which starts with 2
08:41:11 <b_jonas> https://oeis.org/A061418 says under formula that A061418(n) = A061419(n)+1
08:41:29 <ais523> https://oeis.org/A386792
08:41:38 <ais523> MarkFan8901: same sequence, just a different starting value
08:41:46 <ais523> 8 (as opposed to 2 for Hydra)
08:42:07 <b_jonas> so https://oeis.org/A386792 ?
08:42:24 <ais523> it's pretty chaotic for any non-integer, I think
08:42:40 <ais523> err, non-integer greater than 1
08:43:24 <ais523> (as long as you start with a value sufficiently large that you don't get a sequence of repeats)
08:43:59 <MarkFan8901> technically pdas couldnt strictly calculuate the hydra sequence even when multiplying by a <1 value without cheating
08:44:19 <ais523> right, but they can cheat very easily
08:44:32 <ais523> output eventually repeats so you just have to hardcode it…
08:45:27 <MarkFan8901> in the same way, a turing machine can cheat on an uncomputable problem by generating the look-up table that solves it
08:46:00 <ais523> well, only if there are finitely many possible inputs
08:46:13 <ais523> I guess PDAs get stuck the same way if you want to use a value <0.5 but starting with any starting value
08:47:07 <MarkFan8901> maybe a truly unstructured programming language would also have to be meta-turing complete
08:47:35 <MarkFan8901> in the sense that calculating how structures correspond to their programs would also be turing complete
08:47:49 <MarkFan8901> yeah wait that might also be a good starting point
08:48:36 <ais523> hmm, in the spirit of A Pear Tree… "the program must have a CRC-32 hash of 00000000 and must be the shortest such program that computes the same function"
08:49:02 <ais523> (CRC-32 isn't preimage-resistant, which is part of the reason I chose it)
08:49:10 <ais523> https://esolangs.org/wiki/A_Pear_Tree
08:49:59 <ais523> given a hash, determine a string that hashes to that hash
08:50:20 <ais523> cryptographically secure hashing algorithms are designed to be impossible to preimage or collide, this is the main requirement on them
08:50:24 <b_jonas> ais523: that would result in an uncomputable language very soon, right?
08:50:26 <ais523> but some hashes are not cryptographically secure
08:50:44 <MarkFan8901> "Various options are set automatically depending on the presence of input on standard input and on the presence of the letter F in the program" is a hell of a modification
08:51:06 <ais523> b_jonas: it's uncomputable to check whether the program is syntactically correct or not, but not uncomputable to execute it if you treat incorrect programs as UB
08:51:45 <b_jonas> I think that's too weak of a requirement for a cryptographically secure hash, but it's certainly at least a requirement
08:53:03 * ais523 is reminded of https://esolangs.org/wiki/The_Language_That_Explodes
08:53:05 <b_jonas> ais523: oh, I think I misunderstood your specification. and even now it sounds ambiguous.
08:53:19 <ais523> b_jonas: it is too weak, there are other requirements too, but they're less important
08:54:31 <MarkFan8901> ais523: yes that language is what we were getting at when we were talking about chaotic cellular automata
08:54:44 <MarkFan8901> theyre computable but they have uncomputable encodings
08:54:58 -!- [][][][] has changed nick to raiseafloppafan7.
08:55:31 -!- de67 has joined.
08:57:02 <de67> i wanted to say that my definition seems to not be totally correct, just the unique properties being uncomputable seems to be enough
08:57:49 <MarkFan8901> we have a definition we came up with in confluence with talking to ais that we think is more accurate to what he imagines unstructured programming to be
08:57:55 <de67> wow thats a lot of stuff thatvhappened
08:58:05 <de67> who does he refer to?
09:00:20 <MarkFan8901> in a truly unstructured language, calculating how structures correspond to their programs is turing complete
09:00:57 <esolangs> [[Simpl]] https://esolangs.org/w/index.php?diff=197520&oldid=197519 * Cordership * (+332) /* Modules */
09:01:58 <MarkFan8901> that also lets you write programs with structure effectively, but you physically cant use the same structures across different programs
09:02:09 <MarkFan8901> because figuring out how to do that would be either turing complete or uncomputable
09:02:35 <MarkFan8901> ais523: maybe what you're thinking about could be better formulated by the idea of locality
09:02:52 <MarkFan8901> typically, programming languages have some degree of locality to all of their commands
09:03:13 <MarkFan8901> in bf, for example, you can turn an increment to a decrement quite easily
09:03:15 <ais523> I think locality is probably the right point of view here
09:03:32 <MarkFan8901> what you want is a language which provably has no locality
09:03:50 <ais523> although the 2D-trace-over-self and golfing versions both have some amount of locality
09:04:07 <ais523> they both just also have an amount of nonlocality and that's what causes the trouble
09:04:25 <MarkFan8901> maybe neural networks are a prototype of a language which has no locality?
09:04:41 <ais523> neural networks turned out to have quite a lot of locality in practice
09:05:13 <MarkFan8901> we remember our whole thing about how neural networks work by building commands fit for their task
09:05:47 <MarkFan8901> the core idea of having literally everything be connected to literally everything else might be a good starting point though
09:05:59 <ais523> on CGCC there was a competition to write three simple programs that were all anagrams of each other, and make them as short as possible
09:05:59 <MarkFan8901> in the sense of how different layers of networks are connected to each other
09:06:24 <ais523> so characters that were used for one program would ideally be used for the others, rather than just commented out, to save on charactets
09:07:17 <ais523> I wrote my programs in 7 (which has an 8-element character set), meaning that I could use the elements of the string literal in the hello world program to write the entirety of the other two
09:07:38 <ais523> but it was nontrivial, I kept finding savings
09:07:49 <ais523> https://esolangs.org/wiki/7
09:08:00 <de67> im struggling to keep up with allat
09:08:14 <de67> im reading the logs
09:08:18 <de67> some interetsing stuf
09:09:34 <MarkFan8901> maybe some entropy-complete compression of lambda calculus could work?
09:09:45 <MarkFan8901> if you had to write from the perspective of the compression scheme
09:09:53 <int-e> `? entropy-complete
09:09:57 <HackEso> entropy-complete? ¯\(°_o)/¯
09:11:04 <MarkFan8901> entropy completeness is, given any piece of random data, it's valid in the compression scheme
09:11:38 <int-e> so it's incompatible with any self-delimiting encodings? that's... awkward
09:12:12 <MarkFan8901> we think such encodings would actually be chalk full of self-delimiting
09:12:44 <MarkFan8901> just incredibly complicated ways of doing so
09:13:10 <b_jonas> to be honest I don't know what exactly a crypto hash function has to satisfy. if I try to come up with requirements then they're either too weak or too strong.
09:13:31 <MarkFan8901> we feel like a bunch of weak ones would work
09:14:03 <b_jonas> but we have applications where we are using a cryptographic hash function and we require more from it than just simple preimage-resistance
09:17:55 -!- Yayimhere22 has joined.
09:18:40 <MarkFan8901> lots of things have happened since you left
09:20:12 <MarkFan8901> yknow how constraint languages are like declarative programming?
09:20:25 <Yayimhere22> i can ping you and list all the thougts i got in the meanwhile
09:20:25 <MarkFan8901> what would the imperative programming equivalent be
09:21:24 <Yayimhere22> a delcrative program declares a bunch of statements A, which as it goes along slowly distills your "Intent" as I?
09:22:01 <MarkFan8901> it derives the control flow from the statements
09:22:09 <Yayimhere22> cuz then a imperative program (TMK) executes a list of atoms A
09:22:59 <MarkFan8901> a declarative program is a description of what an imperative program *would* do
09:23:08 <MarkFan8901> and execution of a declarative program is finding that program
09:23:22 <MarkFan8901> in the case of constraint languages, that's solving for the program
09:23:23 <Yayimhere22> cuz then constraint languages makes A into the constraints C, and I into the language family F?
09:24:36 <Yayimhere22> in declarative programming you have AI. but in a imperative program you have the IP(instruction pointer)???
09:25:13 <esolangs> [[Simpl]] https://esolangs.org/w/index.php?diff=197521&oldid=197520 * Cordership * (+144) /* Module 8: str */
09:25:22 <esolangs> [[Simpl]] https://esolangs.org/w/index.php?diff=197522&oldid=197521 * Cordership * (+0) /* Module 8: str */
09:25:47 <Yayimhere22> i guess its about sideffects more than anything?
09:25:48 <MarkFan8901> in imperative programming you're given a program to execute the code
09:26:17 <MarkFan8901> you have to use ai to find the code to execute
09:26:32 <de67> ive finally read the logs
09:26:34 <Yayimhere22> and in imperative you have to use an IP to execute
09:26:38 <de67> god that was was exhausting
09:26:47 <MarkFan8901> Yayimhere22: again consider the waterfall model
09:26:48 <de67> but it was interesting
09:27:00 <MarkFan8901> what if the ip was instead in the rules of the language
09:27:29 <de67> now i meed to read logs since 08:55 utc...
09:28:07 <de67> ill skip that for now
09:28:55 <esolangs> [[Simpl]] https://esolangs.org/w/index.php?diff=197523&oldid=197522 * Cordership * (-494)
09:28:57 <de67> the "all programs have to be writeen from scratch" thing" remind me of hammerandsickle phase 1
09:29:05 <Yayimhere22> i think its kinda like i think maybe imperative and declarative are different *kinds* of ways to define what kind of language a language is. Like theres functional vs imperative, and then theres declarative vs [un-declarative whatever that is], i dont think its declarative vs imperative
09:29:25 <MarkFan8901> you mean like declarative and imperative arent opposites
09:29:41 <Yayimhere22> or like they aren't on the same spectrum of
09:29:45 <de67> in hammerandsickle phase 1, every instruction changes how the rest of the program is interpreted
09:29:56 <de67> so a piece of code is not reusable
09:30:48 <MarkFan8901> MarkFan8901: perhaps a good definition would be that imperative execution can be modeled with an fsa
09:31:42 <de67> yayimhere22: you can have pda+tape
09:31:46 <de67> which is what brainfuck si
09:32:41 <MarkFan8901> but we're trying to think of exceptions to that
09:32:45 <de67> declarative is basically you have some properties, and the output must have the propertues
09:33:00 <MarkFan8901> yea and you need some sort of ai to do that
09:33:01 <Yayimhere22> so you find mapping of FSA -> AI, and MEM -> DEFINITIONS
09:33:15 <MarkFan8901> Yayimhere22: dunno how formal that mapping is
09:33:34 <MarkFan8901> we would suggest you use more informal terms so its less ambiguous as to what youre trying to say
09:33:48 <Yayimhere22> markfan8901: im just trying to get a basis on how this could be formalised
09:34:03 <MarkFan8901> how would you describe all of this without trying to do that
09:34:43 <Yayimhere22> idk how i would describe it without that im very sorrly
09:34:43 <MarkFan8901> perhaps you need to think about your thoughts more
09:35:31 <MarkFan8901> typically when you cant describe ideas in words well, it means the ideas are currently fuzzy and vague
09:35:31 <de67> if i understand everything correctly, a misnky machine is a fsa hooked up to an array of counters
09:35:41 <de67> it can increment and decrement any counter
09:35:56 <de67> and check any counter if its 0, and change its state based on that
09:36:35 <de67> a turing machine is the same but the counters are bounded and the tape is infinite
09:36:48 <MarkFan8901> what if bf is fsa+mem but one of the commands an fsa can do is fetch the current cell
09:37:25 <MarkFan8901> or do we misunderstand where it being a pda comes from
09:37:29 <Yayimhere22> to get the constraint language equavilent for an imperative language, one way to do that is to find out first how to turn an imperative language into a declarative language. because then you get the constraint lnauggae out of the delcarative language which was made from an imperative one
09:37:43 <Yayimhere22> ill have more clear thoughts when i get home prolly
09:37:48 -!- Yayimhere22 has quit (Quit: Client closed).
09:37:53 <de67> MarkFan8901: now that im thinking of it, any program for a turing machine is better visualized as a graph
09:38:24 <MarkFan8901> one where the nodes are states and the edges are conditionals
09:38:39 <MarkFan8901> and you have a set of conditionals you can pick from the same way you have a set of states
09:38:43 <de67> cya Yayimheret22
09:39:07 <MarkFan8901> oh this also models nondeterministic tms very well too
09:39:49 -!- ais523 has quit (Quit: quit).
09:39:59 <de67> weighyed graphs?
09:40:22 <de67> weighted graphs are graphs where each edge has a weight
09:40:33 <de67> this is usually used in nondeterministic algorithms
09:40:55 <de67> the probabilities?
09:41:11 <MarkFan8901> ye thats for probabilistic algorithms specifically
09:41:20 <MarkFan8901> which are a subset of nondeterministic algorithms
09:42:14 <MarkFan8901> the strict definition of a nondeterministic algorithm is simply one where there can be multiple correct paths to be taken at some point in it
09:42:50 <MarkFan8901> typically all correct paths are taken at the same time; probabilistic algorithms are unique in that they pick only one
09:43:18 <b_jonas> I don't know what languages count as declarative, and I'm pretty sure people disagree on what counts as functional languages. I made https://esolangs.org/wiki/Olvashat%C3%B3 for a university class that is called "declarative programming", a class that teaches about Standard ML and Prolog. But the category sounds fuzzy and I don't really know what else it includes and excludes.
09:44:15 <b_jonas> I'm also not sure about what counts as imperative, another fuzzy category.
09:44:49 <de67> b_jonas: to me it always was, this thing happens, then that thing happens, then that other things happens
09:45:03 <de67> where the programmer has direct control over the sequence of actions
09:45:07 <MarkFan8901> we've just been coming up with definitions that make talking aobut esolangs more useful
09:46:00 <MarkFan8901> oh another thing about functional programming
09:46:10 <b_jonas> the esowiki has https://esolangs.org/wiki/Declarative_paradigm and https://esolangs.org/wiki/Functional_paradigm that try to explain this, but that doesn't match the use of declarative that I mentioned.
09:46:16 <MarkFan8901> originally it meant programming which focused on functionality instead of values
09:46:28 <b_jonas> fortunately I think these are categories where I don't have to know what they mean
09:46:46 <MarkFan8901> either that or its more of a social category
09:47:32 <MarkFan8901> imperative programming is a paradigm the same way soda is a kind of drink
09:47:50 <de67> its quite similar to how most oiscs can be described as very complicated ziscz
09:48:14 <MarkFan8901> perhaps anything can be described as extremely complicated ziscs
09:48:36 <MarkFan8901> ones which just grow the semantics of a commanded language in their complexity
09:54:23 <MarkFan8901> okay jeez we think we got lost in the sauce there for a while
10:00:06 -!- ais523 has joined.
10:01:23 <ais523> The Waterfall Model does sort-of have an instruction pointer (the waterclock with the lowest value acts a lot like an instruction pointer)
10:01:42 <ais523> but the data storage and control flow is all mixed up, which helps to make it easier to implement as they're both treated the same way
10:05:36 -!- de67 has quit (Remote host closed the connection).
10:10:42 <esolangs> [[Simpl]] https://esolangs.org/w/index.php?diff=197524&oldid=197523 * Cordership * (+194)
10:13:44 <esolangs> [[Simpl]] https://esolangs.org/w/index.php?diff=197525&oldid=197524 * Cordership * (+113)
10:15:21 -!- ais523 has quit (Quit: quit).
10:15:26 <b_jonas> ais523: so there's something that I find funny. TAOCP chapter 1.3.1 says that "There are nine registers in MIX", listing them as A, X, I1..=I6, J, then says "Besides its registers, MIX contains an overflow toggle […]; a comparison indicator […]; memory (4000 words of storage […]); and input-output devices […]". It also has a figure 13 that shows exactly the registers and other elements listed
10:15:32 <b_jonas> above. But this list specifically doesn't include the program counter (instruction pointer). And MMIX is described the same way, without explicitly saying that there's a program counter that's part of the machine's state. Whereas I would say that the program counter is a register in both MIX and MMIX. This is just a terminology difference, not semantic, it's not like these machines treat the program
10:15:38 <b_jonas> counter differently from eg. x86. But I find it funny.
10:24:03 -!- esolangs has joined.
10:24:03 -!- ChanServ has set channel mode: +v esolangs.
10:24:18 -!- MarkFan8901 has joined.
10:24:31 -!- Bowserinator has joined.
10:25:39 -!- [][][][] has changed nick to raiseafloppafan7.
10:33:06 -!- de67 has joined.
10:34:03 -!- raiseafloppafan7 has quit (Quit: raiseafloppafan7).
10:34:44 -!- ChimeraAnova has joined.
10:34:44 -!- PkmnQ has joined.
10:39:28 <esolangs> [[Talk:Turtlefuck]] https://esolangs.org/w/index.php?diff=197526&oldid=197486 * None1 * (+391)
10:39:58 <PkmnQ> "<ais523> but, e.g., Tableaux and Banana Scheme are hard to compile between each other and probably don't have the same computational class" i think Tableaux is more powerful than Banana Scheme, or at the very least I couldn't figure out a way to implement Tableaux into Banana Scheme the last time I tried
10:53:35 <esolangs> [[Entitia]] N https://esolangs.org/w/index.php?oldid=197527 * Cordership * (+453) Created page with "Entitia by [[User:Cordership]], is an esolang based on entities. ==Syntax== *Values: Integers. *Transforms: **<code>VT</code> transforms take in 1 entity and produce either another entity or a transform. **<code>PS</code> produces another entity. Making a semi-entity:
10:53:50 <esolangs> [[User:Cordership]] https://esolangs.org/w/index.php?diff=197528&oldid=197226 * Cordership * (+14) /* Esolangs */
11:09:05 -!- ajal has joined.
11:10:36 <esolangs> [[Special:Log/newusers]] create * Vextoly * New user account
11:14:58 <esolangs> [[Esolang:Introduce yourself]] https://esolangs.org/w/index.php?diff=197529&oldid=197402 * Vextoly * (+230)
11:18:21 <esolangs> [[User talk:Blashyrkh/Golf/Code]] M https://esolangs.org/w/index.php?diff=197530&oldid=196735 * Blashyrkh * (+87) introduce some structure for possible further discussions
11:23:47 -!- de67 has changed nick to esom.
11:23:56 -!- esom has changed nick to esomar.
11:24:36 -!- esomar has changed nick to de67].
11:24:39 -!- de67] has changed nick to de67.
11:24:46 -!- de67 has changed nick to []][][][][][][][.
11:28:05 -!- []][][][][][][][ has changed nick to `}`}`}-]`]]`]-]-.
11:28:15 <int-e> the important part is that [] are upper case versions of {}
11:29:20 <int-e> I still think that RFC 1359 did not allow nicks starting with []^{}~
11:32:04 -!- `}`}`}-]`]]`]-]- has changed nick to ^`--]-^``}[^}`-\.
11:32:39 -!- ^`--]-^``}[^}`-\ has changed nick to }[]--[\}}^{[\``^.
11:34:36 -!- PkmnQ has quit (Read error: Connection reset by peer).
11:40:24 -!- }[]--[\}}^{[\``^ has changed nick to de67.
11:44:04 -!- PkmnQ has joined.
11:46:21 <esolangs> [[Talk:ChangeFuck]] N https://esolangs.org/w/index.php?oldid=197531 * Win7HE * (+120) Created page with "i'm pretty sure its turing complete... -- ~~~~"
11:49:27 <esolangs> [[Talk:ChangeFuck]] https://esolangs.org/w/index.php?diff=197532&oldid=197531 * Dragoneater67 * (+200)
11:57:21 -!- PkmnQ has quit (Quit: Leaving).
12:10:33 <esolangs> [[Simpl]] https://esolangs.org/w/index.php?diff=197533&oldid=197525 * Cordership * (+171)
12:15:03 <esolangs> [[Simpl]] https://esolangs.org/w/index.php?diff=197534&oldid=197533 * Cordership * (+128) /* CT interpreter */
12:21:17 <ChimeraAnova> fungot: How much washing contraption sanitizing product should I try consuming for all my days?
12:21:17 <fungot> ChimeraAnova: if something is a little gui stuff in mred, just to prove the haltingness of at least
12:28:48 <esolangs> [[ChangeFuck]] M https://esolangs.org/w/index.php?diff=197535&oldid=187467 * None1 * (+44) /* Usability */
12:29:12 <esolangs> [[Braindrunk]] M https://esolangs.org/w/index.php?diff=197536&oldid=184269 * None1 * (+30)
12:39:45 -!- ChimeraAnova has left.
12:41:50 -!- ChimeraAnova has joined.
12:45:34 <fungot> ChimeraAnova: which client?
12:49:21 -!- de67 has quit (Ping timeout: 260 seconds).
12:51:55 -!- de67 has joined.
12:52:45 <b_jonas> int-e: what? I thought nicks starting with at least []{} were always allowed, there's just a difference between how servers casefold in nicks and channels
12:54:10 <b_jonas> a difference between irc networks in that, not really individual servers
12:54:21 <int-e> b_jonas: <nick> ::= <letter> { <letter> | <number> | <special> }, <letter> ::= 'a' ... 'z' | 'A' ... 'Z'
12:54:31 <b_jonas> and freenode switched from the ASCII casefolding rules to the ISO-646 one IIRC
12:54:43 <b_jonas> int-e: aren't the brackest letters in those definitions?
12:55:04 <int-e> b_jonas: the RFC may not reflect any implementations, of course
12:55:26 <b_jonas> sure, in particular I think freenode usually didn't allow non-ascii characters in channel names while the RFC allows them
12:56:02 -!- ManDeJan has quit (Ping timeout: 270 seconds).
12:59:39 <esolangs> [[Braindrunk]] M https://esolangs.org/w/index.php?diff=197537&oldid=197536 * Blashyrkh * (+0) /* See also */ Fix redlink
13:00:21 -!- ChimeraAnova has changed nick to []{test}.
13:00:40 -!- []{test} has changed nick to []{almost-a-cpp-.
13:00:44 -!- []{almost-a-cpp- has changed nick to []{almost-a-lamb.
13:00:53 -!- []{almost-a-lamb has changed nick to raiseafloppafan7.
13:07:47 -!- ManDeJan has joined.
13:40:05 <esolangs> [[User:Dragoneater67/Sandbox]] https://esolangs.org/w/index.php?diff=197538&oldid=197420 * Dragoneater67 * (+474)
13:42:27 <esolangs> [[Talk:Turtlefuck]] https://esolangs.org/w/index.php?diff=197539&oldid=197526 * Cleverxia * (+185)
13:46:38 <esolangs> [[Talk:Turtlefuck]] https://esolangs.org/w/index.php?diff=197540&oldid=197539 * None1 * (+400) By estimation
13:47:47 <esolangs> [[User:Dragoneater67/Sandbox]] M https://esolangs.org/w/index.php?diff=197541&oldid=197538 * Dragoneater67 * (-591) testin; done
13:48:08 <esolangs> [[BFFuck/3.x plans]] M https://esolangs.org/w/index.php?diff=197542&oldid=197018 * None1 * (+38) /* Bottom-level commands */ Implement move instruction
13:48:37 <esolangs> [[Bitch, Ienai!]] https://esolangs.org/w/index.php?diff=197543&oldid=197421 * Cordership * (+14) /* Definitions */
13:50:04 <esolangs> [[BFFuck]] https://esolangs.org/w/index.php?diff=197544&oldid=197016 * None1 * (+89) /* Syntax */ Add move instruction
13:51:07 <esolangs> [[BFFuck]] https://esolangs.org/w/index.php?diff=197545&oldid=197544 * None1 * (+101)
13:53:36 <HackEso> As of 13:53:35, 06 Oct 2026, we are 83.413664988900% to the end of time, which has gone up 0.019512185836% since this was last ran on 17:29:54, 01 Oct 2026. The next percentile is in 145 days, 17 hours, 37 minutes, and 28 seconds on 07:31:03, 01 Mar 2027.
13:54:10 <esolangs> [[Quaternions]] https://esolangs.org/w/index.php?diff=197546&oldid=196743 * Cleverxia * (+931) fiix wording and add a dialect
13:54:38 <HackEso> cat: /hackenv/bin/eot.lua: No such file or directory
13:54:43 <esolangs> [[Entitia]] https://esolangs.org/w/index.php?diff=197547&oldid=197527 * Cordership * (+697)
13:54:43 <aadenboy> `cat /hackenv/bin/endoftime.lua
13:54:46 <HackEso> -- this is messily written but whatever \ local last = io.open("/hackenv/tmp/eotlast", "r") \ local u = os.time() \ local lt = last and tonumber(last:read("*n")) \ if last then last:close() end \ local f = "!%H:%M:%S, %d %b %Y" \ local np = math.floor(math.ceil(u/2147483647*100)/100*(2^31-1)) \ local pdiff = np-u \ local d = os.date \ function plural(n, s) return n.." "..s:sub(1, n == 1 and -2 or -1) end \ local ds = {} \ if pdiff > 86400 then ds[
13:54:47 <esolangs> [[Quaternions]] M https://esolangs.org/w/index.php?diff=197548&oldid=197546 * Cleverxia * (+5) why is my edits bugging so much
13:55:37 <aadenboy> `lua -eprint(os.date("!%H:%M:%S, %d %b %Y", math.floor(os.time()+0.1*(2^31-1))))
13:55:38 <esolangs> [[Quaternions]] M https://esolangs.org/w/index.php?diff=197549&oldid=197548 * Cleverxia * (+11) /* Octonerions */
13:56:15 <aadenboy> `lua -eprint(os.date("!%H:%M:%S, %d %b %Y", math.floor(os.time()+0.001*(2^31-1))))
13:56:56 <esolangs> [[BFFuck]] M https://esolangs.org/w/index.php?diff=197550&oldid=197545 * None1 * (+11) /* External Resources */
13:58:12 <esolangs> [[Quaternions]] M https://esolangs.org/w/index.php?diff=197551&oldid=197549 * Blashyrkh * (+0) /* Interpreter */ fix typo
14:00:57 <esolangs> [[Entitia]] https://esolangs.org/w/index.php?diff=197552&oldid=197547 * Cordership * (+58)
14:01:35 <esolangs> [[Talk:Quaternions]] https://esolangs.org/w/index.php?diff=197553&oldid=196726 * Blashyrkh * (+137) /* Proper spelling */ new section
14:06:32 <FireFly> b_jonas: I think the ircd before ircd-seven did, because I was in a channel prior to the upgrade (on freenode) that couldn't be joined after
14:07:20 <esolangs> [[Talk:Quaternions]] https://esolangs.org/w/index.php?diff=197554&oldid=197553 * Blashyrkh * (+136) /* Proper spelling */
14:07:44 <b_jonas> the libera server doesn't seem to allow non-ascii channel names, at least some of them
14:19:50 -!- Sgeo has joined.
14:21:29 -!- PkmnQ has joined.
14:26:27 -!- Lord_of_Life has quit (Quit: Laa shay'a waqi'un moutlaq bale kouloun moumkine).
14:32:10 -!- Lord_of_Life has joined.
14:37:32 -!- Lord_of_Life has quit (Quit: Laa shay'a waqi'un moutlaq bale kouloun moumkine).
14:38:24 -!- Lord_of_Life has joined.
14:38:26 <esolangs> [[23]] M https://esolangs.org/w/index.php?diff=197555&oldid=197417 * PkmnQ * (+2) /* Initialization */
14:51:27 -!- Lord_of_Life has quit (Quit: Laa shay'a waqi'un moutlaq bale kouloun moumkine).
15:04:13 -!- PkmnQ has quit (Quit: Leaving).
15:16:12 -!- Lord_of_Life has joined.
15:24:26 <esolangs> [[Polynomix/Symbols]] https://esolangs.org/w/index.php?diff=197556&oldid=188959 * I am islptng * (+385)
15:30:48 -!- raiseafloppafan7 has quit (Quit: I've become sleepy.).
16:02:31 <esolangs> [[Bitch, Ienai!]] https://esolangs.org/w/index.php?diff=197557&oldid=197543 * Yayimhere2(school) * (-14) Undo revision [[Special:Diff/197543|197543]] by [[Special:Contributions/Cordership|Cordership]] ([[User talk:Cordership|talk]]) unneeded/implied
16:02:51 -!- yayimheretoo has joined.
16:11:27 -!- yayimheretoo has quit (Quit: Client closed).
16:13:46 -!- jix has quit (Ping timeout: 266 seconds).
16:14:30 -!- jix has joined.
16:16:23 -!- yayimheretoo has joined.
16:17:07 <de67> yayimheretoo: plz join esolang.forum
16:18:46 -!- de67 has quit (Quit: FUNGOT WILL END US ALL!!!).
16:26:54 -!- CRISPR has joined.
16:44:44 -!- APic has quit (Ping timeout: 242 seconds).
16:46:49 -!- Riviera has quit (Ping timeout: 245 seconds).
16:47:00 -!- de67 has joined.
16:47:18 -!- de67 has quit (Remote host closed the connection).
16:52:09 -!- Riviera has joined.
16:53:32 -!- Lymia has quit (Quit: zzzz <3).
16:54:23 -!- Lymia has joined.
17:16:18 <esolangs> [[User:Miui/Sandbox]] https://esolangs.org/w/index.php?diff=197558&oldid=196436 * Miui * (+60) /* Works in progress */ add septemdecagams
17:26:12 <esolangs> [[User:Miui/septemdecagams]] N https://esolangs.org/w/index.php?oldid=197559 * Miui * (+7742) initial sketch of an septemdecagam
17:34:03 -!- Lord_of_Life has quit (Quit: Laa shay'a waqi'un moutlaq bale kouloun moumkine).
17:40:55 -!- Lord_of_Life has joined.
17:48:42 -!- yayimheretoo has quit (Quit: Client closed).
17:50:21 <esolangs> [[Bitch, Ienai!]] M https://esolangs.org/w/index.php?diff=197560&oldid=197557 * MarkFan8901 * (+19)
17:51:05 -!- inhahe has joined.
18:23:00 <MarkFan8901> ais523: what if you had a 2d language where, instead of moving one square at a time, it 'jumps' over multiple at a time
18:23:36 <MarkFan8901> and how many squares it jumps over is tied to how big the program is
19:04:55 -!- APic has joined.
19:26:50 <fizzie> Funge-98 has the former (but not the latter), in that you can set the direction to be an arbitrary vector.
19:45:29 -!- CRISPR has quit (Ping timeout: 268 seconds).
19:50:03 <MarkFan8901> actually what if the vector was determined by the sum of all of the individual commands in the program
19:50:45 <MarkFan8901> we feel like that would make it easy to deliberately construct vectors, but probably harder to write programs within that constraint
19:50:50 <MarkFan8901> the important part is that that wouldnt be impossible
19:51:01 <MarkFan8901> but it *would* be impossible to try to modify such a program
20:06:25 -!- Lord_of_Life has quit (Quit: Laa shay'a waqi'un moutlaq bale kouloun moumkine).
20:07:44 -!- Lord_of_Life has joined.
20:17:20 <MarkFan8901> <PkmnQ: i *think* Tableaux is more powerful than Banana Scheme, or at the very least I couldn't figure out a way to implement Tableaux into Banana Scheme the last time I tried>: that might be because banana scheme is just scheme but with an infinite amount of oracles for solving the halting problem
20:17:38 <MarkFan8901> whereas tableaux can solve any given uncomputable problem
20:18:50 <esolangs> [[Talk:BFFuck]] https://esolangs.org/w/index.php?diff=197561&oldid=195973 * Assembly * (+26) /* Brainfuckfuck */ new section
20:18:59 <esolangs> [[Talk:BFFuck]] https://esolangs.org/w/index.php?diff=197562&oldid=197561 * Assembly * (+157) /* Brainfuckfuck */
20:34:32 -!- sprock has joined.
20:48:41 <esolangs> [[Kcufniarb (ais523)]] https://esolangs.org/w/index.php?diff=197563&oldid=197515 * Hotcrystal0 * (+5) this
21:03:23 <esolangs> [[User:Miui/Sandbox]] https://esolangs.org/w/index.php?diff=197564&oldid=197558 * Miui * (+59) /* Works in progress */ add Never Twice the Same (NTSC)
21:03:39 <esolangs> [[Never Twice the Same (NTSC)]] N https://esolangs.org/w/index.php?oldid=197565 * Miui * (+1110) post sketches
21:06:41 <esolangs> [[User:Blashyrkh/Golf/Code]] https://esolangs.org/w/index.php?diff=197566&oldid=197448 * Blashyrkh * (+222) Primes @ [[14]] (121 bytes)
21:08:35 <esolangs> [[User:Blashyrkh/Golf]] https://esolangs.org/w/index.php?diff=197567&oldid=197450 * Blashyrkh * (+51) Primes @ [[14]] (121 bytes)
21:15:59 <esolangs> [[User:Hotcrystal0/Sandbox]] https://esolangs.org/w/index.php?diff=197568&oldid=196971 * Hotcrystal0 * (+152)
21:26:26 -!- Lord_of_Life has quit (Quit: Laa shay'a waqi'un moutlaq bale kouloun moumkine).
21:29:21 <esolangs> [[14]] https://esolangs.org/w/index.php?diff=197569&oldid=196231 * Blashyrkh * (+261) /* Examples */ Prime number generator
21:43:55 <esolangs> [[Talk:14]] https://esolangs.org/w/index.php?diff=197570&oldid=195369 * Blashyrkh * (+390) /* Examples */ new section
21:48:30 <esolangs> [[User:Aadenboy/546372]] https://esolangs.org/w/index.php?diff=197571&oldid=196331 * Aadenboy * (+7)
21:54:53 -!- Lord_of_Life has joined.
22:01:16 -!- sprock has quit (Ping timeout: 262 seconds).
22:04:00 -!- Lord_of_Life has quit (Quit: Laa shay'a waqi'un moutlaq bale kouloun moumkine).
22:05:39 <esolangs> [[BF-PDA]] M https://esolangs.org/w/index.php?diff=197572&oldid=189077 * MarkFan8901 * (-14) fix names
22:05:59 <esolangs> [[BF-SC]] M https://esolangs.org/w/index.php?diff=197573&oldid=14118 * MarkFan8901 * (-9) fix name
22:24:57 -!- ajal has quit (Remote host closed the connection).
22:40:07 -!- Lord_of_Life has joined.
23:00:59 -!- CRISPR has joined.
23:30:19 <esolangs> [[User:Tommyaweosme]] https://esolangs.org/w/index.php?diff=197574&oldid=195348 * Tommyaweosme * (+113)
23:30:24 <esolangs> [[User:Tommyaweosme]] https://esolangs.org/w/index.php?diff=197575&oldid=197574 * Tommyaweosme * (+1)
23:36:43 -!- CRISPR has quit (Ping timeout: 258 seconds).
23:38:42 -!- Lord_of_Life has quit (Quit: Laa shay'a waqi'un moutlaq bale kouloun moumkine).
23:42:25 -!- Lord_of_Life has joined.
23:57:22 <MarkFan8901> we're thinking about how making a solver from natural language to some other language would work without an llm
23:57:55 <MarkFan8901> and we thought about somehow formalizing how natural language works
23:58:13 <MarkFan8901> we've actually kind of done this before, at least for the structure of one
23:58:44 <MarkFan8901> the idea is that a sentence is a tree, where each node has either 1 or 2 children
23:59:14 <MarkFan8901> leaves are called nouns, single-child nodes are called adjectives, and double-child nodes are verbs