←2019-07-31 2019-08-01 2019-08-02→ ↑2019 ↑all
00:05:46 -!- adu has quit (Quit: adu).
00:44:34 <tswett[m]> So it turns out writing machine code can be kind of tedious.
01:43:53 <esowiki> [[Your Pillows]] N https://esolangs.org/w/index.php?oldid=64877 * A * (+1073) Created page with "[[Your Pillows]] are [[esoteric programming language]]s directly based off pillows. It is somehow influenced by [[Brace For Impact]] and [[Beatnik]]. ==Syntax of your pillows=..."
01:55:50 <esowiki> [[Ummm...]] M https://esolangs.org/w/index.php?diff=64878&oldid=59008 * A * (+190)
01:56:22 -!- adu has joined.
01:57:33 <esowiki> [[Your Pillows]] M https://esolangs.org/w/index.php?diff=64879&oldid=64877 * A * (+197) /* Instructions */
02:04:41 -!- FreeFull has quit.
02:35:00 <int-e> `? password
02:35:01 <HackEso> The password of the month is int-e's job.
02:41:11 <int-e> `learn The password of the month is surprising.
02:41:14 <HackEso> Relearned 'password': The password of the month is surprising.
03:21:35 <esowiki> [[Talk:ACL]] https://esolangs.org/w/index.php?diff=64880&oldid=64862 * JonoCode9374 * (+138) /* Python Interpreter */
03:23:49 <esowiki> [[ACL]] https://esolangs.org/w/index.php?diff=64881&oldid=64870 * JonoCode9374 * (+449) /* Technical Regarding Interpreter */ Python interpreter done!
03:26:32 -!- xkapastel has quit (Quit: Connection closed for inactivity).
04:36:50 -!- doesthiswork has quit (Ping timeout: 248 seconds).
06:11:29 <esowiki> [[User talk:A]] M https://esolangs.org/w/index.php?diff=64882&oldid=64766 * A * (-13424) Remove all of them; it is always visible in the page history.
06:12:11 <esowiki> [[User talk:A]] M https://esolangs.org/w/index.php?diff=64883&oldid=64882 * A * (+632) /* Blocked */
06:12:44 <esowiki> [[User talk:A]] M https://esolangs.org/w/index.php?diff=64884&oldid=64883 * A * (+3) /* Game */
06:14:21 <esowiki> [[User talk:A]] M https://esolangs.org/w/index.php?diff=64885&oldid=64884 * A * (-337) /* Game */
06:23:53 <esowiki> [[User talk:A]] M https://esolangs.org/w/index.php?diff=64886&oldid=64885 * A * (+905) /* Game */
06:24:09 <esowiki> [[User talk:A]] M https://esolangs.org/w/index.php?diff=64887&oldid=64886 * A * (+17) /* One */
07:34:08 -!- Sgeo_ has joined.
07:37:07 -!- Sgeo__ has quit (Ping timeout: 245 seconds).
07:37:20 -!- adu has quit (Read error: Connection reset by peer).
07:38:02 -!- adu has joined.
07:59:01 -!- Frater_EST has joined.
08:05:10 -!- Lord_of_Life has quit (Ping timeout: 272 seconds).
08:05:30 -!- Lord_of_Life has joined.
08:09:29 <esowiki> [[User talk:A]] M https://esolangs.org/w/index.php?diff=64888&oldid=64887 * A * (+1170) /* One */
08:11:49 <esowiki> [[User talk:A]] M https://esolangs.org/w/index.php?diff=64889&oldid=64888 * A * (+24) /* Game */
08:35:52 -!- cpressey has joined.
08:36:03 <esowiki> [[Deadfish Joust]] N https://esolangs.org/w/index.php?oldid=64890 * A * (+1732) Created page with "[[Deadfish Joust]] is a [[deadfish]]-based game, consisting of two contestants who attempt to modify an accumulator to make the accumulator as close to their value as possib..."
08:39:44 -!- Frater_EST has left.
08:40:07 <esowiki> [[ACL]] https://esolangs.org/w/index.php?diff=64891&oldid=64881 * Hanzlu * (+0)
08:41:16 <esowiki> [[User talk:A]] https://esolangs.org/w/index.php?diff=64892&oldid=64889 * A * (-2414) /* Game (code golf in deadfish) */
08:47:33 <esowiki> [[Talk:Deadfish Joust]] N https://esolangs.org/w/index.php?oldid=64893 * JonoCode9374 * (+208) Created page with "= Contest controller = I might try and make a simple offline controller in python. ~~~~"
08:56:15 <esowiki> [[Talk:ACL]] https://esolangs.org/w/index.php?diff=64894&oldid=64880 * Hanzlu * (+721) /* Python Interpreter */
08:57:25 <esowiki> [[ACL]] https://esolangs.org/w/index.php?diff=64895&oldid=64891 * Hanzlu * (+40)
08:59:13 <cpressey> Good morning. How is brainfuck not a concatenative language?
09:00:14 <cpressey> Instead of taking a stack to a stack, each function takes (tape, control context) -> (tape, control context)
09:00:59 <cpressey> (I actually see where this breaks down, but it's interesting to think about nonetheless)
09:06:12 <Taneb> cpressey: have you seen https://esolangs.org/wiki/Pure_BF
09:07:22 <cpressey> Taneb: Not sure. Maybe, a long time ago.
09:08:13 <cpressey> So to do anything interesting with control context in a concatenative language, do you need to support storing function values somehow in the state that your functions work on?
09:12:03 <cpressey> I think the answer is "yes" in some weak sense
09:12:26 <cpressey> There is probably a lot of wiggle room in "somehow"
09:12:53 <Taneb> There's also some room in "interesting"
09:15:54 <cpressey> Indeed
09:16:19 <cpressey> And even "concatenative" - I get the impression that a lot of concatenative languages are purely so
09:16:24 <cpressey> *aren't
09:23:21 <cpressey> How about "second-order concatenative" - you have functions (stack -> stack), in monoids, but these monoids are embedded in an "outer" monoid where the functions are ((stack -> stack) -> (stack -> stack))
09:23:58 <cpressey> Pure BF++
09:28:27 <cpressey> You could make it "look concatenative" by having the inner monoids seperated by a single | character or something (rather than being enclosed in some kind of brackets, which seems more conventional)
09:28:55 <cpressey> : and ; count as brackets, if you're Forth
09:30:40 <esowiki> [[Talk:ACL]] https://esolangs.org/w/index.php?diff=64896&oldid=64894 * JonoCode9374 * (+349)
09:44:15 <esowiki> [[Talk:ACL]] https://esolangs.org/w/index.php?diff=64897&oldid=64896 * Hanzlu * (+59)
09:47:15 <cpressey> Or maybe there are two disjoint sets of characters, "inner" and "outer".
09:47:22 <esowiki> [[Talk:Deadfish Joust]] M https://esolangs.org/w/index.php?diff=64898&oldid=64893 * A * (+171)
09:47:41 <cpressey> The (stack -> stack) functions also need to... be stacked in a stack or something
09:48:01 <cpressey> Not sure
09:48:07 <cpressey> This might be worth working out
09:48:35 <esowiki> [[Deadfish Joust]] M https://esolangs.org/w/index.php?diff=64899&oldid=64890 * A * (+27)
09:50:28 <esowiki> [[Language list]] M https://esolangs.org/w/index.php?diff=64900&oldid=64796 * A * (+19) /* Y */
09:51:33 <esowiki> [[Joke language list]] M https://esolangs.org/w/index.php?diff=64901&oldid=64561 * A * (+75) /* General languages */
09:54:42 <esowiki> [[Deadfish Joust]] M https://esolangs.org/w/index.php?diff=64902&oldid=64899 * A * (+294)
09:57:47 <esowiki> [[Deadfish Joust]] M https://esolangs.org/w/index.php?diff=64903&oldid=64902 * A * (+166)
09:59:27 <esowiki> [[Deadfish Joust]] https://esolangs.org/w/index.php?diff=64904&oldid=64903 * A * (+66) /* Typing */
10:03:21 <esowiki> [[Deadfish Joust]] https://esolangs.org/w/index.php?diff=64905&oldid=64904 * A * (+17) /* Typing */
10:04:59 <esowiki> [[User:Hanzlu]] https://esolangs.org/w/index.php?diff=64906&oldid=64876 * Hanzlu * (+215)
10:05:23 -!- FraterEST has joined.
10:05:37 -!- FraterEST has left.
10:09:36 <esowiki> [[ACL]] https://esolangs.org/w/index.php?diff=64907&oldid=64895 * Hanzlu * (+118)
10:20:34 <cpressey> The second-order functions don't need to be stacked, there just needs to be a second-order identity function that can be second-order composed with other second-order functions
10:21:22 <Taneb> cpressey: is this related to higher dimensional category theory?
10:21:35 <cpressey> As soon as you see an "outer" character (representing a second-order function) you take all the first-order functions that you have been collecting so far ("inner" characters) and make a second-order function out of it
10:22:06 <cpressey> Taneb: not to my knowledge
10:22:26 <cpressey> I'm sure someone could *make* it related to that if they tried hard enough
10:23:49 -!- wob_jonas has joined.
10:24:51 <wob_jonas> ``` card-by-name "$(ping)"
10:24:52 <HackEso> Pongify \ U \ Instant \ Destroy target creature. It can't be regenerated. Its controller creates a 3/3 green Ape creature token. \ PLC-U, C14-U
10:26:51 <esowiki> [[ACL]] https://esolangs.org/w/index.php?diff=64908&oldid=64907 * Hanzlu * (-65)
10:29:35 <cpressey> A monoid is a category with one object. Maybe this is a category with two objects.
10:30:07 <cpressey> That would be my bet, but I don't like category theory so I tend not to think in those terms.
10:33:59 <esowiki> [[Smalllang]] N https://esolangs.org/w/index.php?oldid=64909 * A * (+1381) Created page with "[[Smalllang]] is a joke [[esoteric programming language]] created in order to fullfill [[User:Hanzlu]]'s definition of a usable language, as it tries its best to make itself..."
10:35:41 <Taneb> Hmm, it's kind of like a 2-monoid (by analogy with 2-category)
10:42:12 <wob_jonas> ``` cd wisdom; find -type f -printf "%s %p\n" | sort -n # shortest wisdoms
10:47:29 <cpressey> https://cemulate.github.io/the-mlab/ is just as good as the nLab as far as I'm concerned.
10:58:39 -!- wob_jonas has quit (Quit: Ping timeout (120 seconds)).
11:03:44 <esowiki> [[Hello world program in esoteric languages]] https://esolangs.org/w/index.php?diff=64910&oldid=64179 * Hanzlu * (+160)
11:05:43 <int-e> `cwlprits nak
11:05:45 <HackEso> oerjän oerjän
11:05:52 <int-e> `cwlprits output
11:05:54 <HackEso> oerjän oerjän oerjän olsnër
11:06:01 <int-e> odd.
11:06:07 <int-e> `hwrl nak
11:06:09 <HackEso> https://hack.esolangs.org/repo/log/tip/wisdom/nak
11:21:10 <esowiki> [[User:Hanzlu]] https://esolangs.org/w/index.php?diff=64911&oldid=64906 * Hanzlu * (+155)
11:29:47 <esowiki> [[Joke language list]] M https://esolangs.org/w/index.php?diff=64912&oldid=64901 * A * (+50)
11:30:37 <esowiki> [[Smalllang]] https://esolangs.org/w/index.php?diff=64913&oldid=64909 * Hanzlu * (+454)
11:31:18 <esowiki> [[Smalllang]] https://esolangs.org/w/index.php?diff=64914&oldid=64913 * Hanzlu * (-2)
11:32:57 <cpressey> I think the category is just called <b>2</b>; two objects a, b and a single non-identity arrow a -> b
11:33:46 <cpressey> I *guess* that arrow corresponds to lifting a (S->S) into a ((S->S)->(S->S)) in this case
11:35:13 <cpressey> Unless...? Maybe there are more arrows than these here
11:41:58 <int-e> cpressey: hmpf. I thought 2 has no arrow at all
11:42:04 <int-e> (non-identity)
11:42:31 <cpressey> int-e: there seems to be some controversy about that: https://math.stackexchange.com/a/1227142
11:42:41 <int-e> Not that I care much. I regard category theory as unnecessary obfuscation.
11:43:03 <esowiki> [[Smalllang]] M https://esolangs.org/w/index.php?diff=64915&oldid=64914 * A * (+276) I can still use it to create an infinite loop. (Now I can't.)
11:43:27 <int-e> (because the only way *I* can make sense of it is to translate everything back into concrete categories)
11:43:59 <cpressey> I definitely prefer thinking in terms of algebraic structures myself
11:44:50 <esowiki> [[Smalllang]] M https://esolangs.org/w/index.php?diff=64916&oldid=64915 * A * (+43) /* Interpreter */
11:45:07 -!- aloril_ has joined.
11:45:19 <int-e> and that backtranslation stops working somewhere around natural transformations (probably still just fine) and adjoint functors :P
11:46:59 <cpressey> If I ever need them I know where to look for them
11:47:08 <cpressey> (I will never, ever need them)
11:47:13 <cpressey> (Famous last words)
11:47:30 <esowiki> [[Smalllang]] https://esolangs.org/w/index.php?diff=64917&oldid=64916 * A * (+69) /* Interpreter */ Error handling
11:47:44 <int-e> As last words go, these have a good chance of being true at that point...
11:48:08 -!- wob_jonas has joined.
11:48:08 <esowiki> [[Smalllang]] M https://esolangs.org/w/index.php?diff=64918&oldid=64917 * A * (+43) /* Interpreter */
11:48:41 -!- aloril has quit (Ping timeout: 268 seconds).
11:48:41 <int-e> `grWp wombat
11:48:43 <HackEso> No output.
11:50:09 <int-e> . o O ( "Air? Where we're going we won't need ai--" )
11:53:37 -!- aloril_ has quit (Ping timeout: 268 seconds).
11:54:14 <esowiki> [[Talk:Deadfish Joust]] https://esolangs.org/w/index.php?diff=64919&oldid=64898 * A * (+2) /* Contest controller */ This is indeed odd.
11:55:41 <cpressey> I was thinking there might need to be another arrow, because the result of all this concatenating is going to be a function ((S->S)->(S->S)) but you probably want to run it on some input data, which would be an S, not an (S->S).
11:56:22 <cpressey> You'd want to be able to lift and, uh. Forget?
11:56:50 <cpressey> Or maybe you just lift the input instead
11:57:06 -!- aloril_ has joined.
11:57:42 <int-e> where is this going, all linear languages are concatenative if you build the parser state into the semantics?
11:58:39 <wob_jonas> int-e: there was some such parody about that, claiming that x86 assembly was concatenative
12:00:36 <cpressey> I think https://catseye.tc/article/List_of_Unfinished_Interesting_Esolangs#paneer is probably related to that
12:01:40 <int-e> hmm. all you need is a call-with-current-input
12:02:18 <int-e> So tromp's BLC is a simple candidate.
12:02:28 <cpressey> I wasn't planning to go anywhere near that far with this idea, I just want a second-order concatenative language right now
12:03:18 <esowiki> [[Smalllang]] M https://esolangs.org/w/index.php?diff=64920&oldid=64918 * A * (+29) /* Instructions */
12:03:47 <esowiki> [[Smalllang]] M https://esolangs.org/w/index.php?diff=64921&oldid=64920 * A * (+0) /* Instructions */
12:03:58 <esowiki> [[BLC]] N https://esolangs.org/w/index.php?oldid=64922 * Int-e * (+36) add redirect for semi-common abbreviation
12:04:08 <wob_jonas> I'd still like to see a language that is based on SKI calculus, the way that unlambda is, but uses something like Haskell's IO to do interactive IO
12:05:36 <esowiki> [[Smalllang]] M https://esolangs.org/w/index.php?diff=64923&oldid=64921 * A * (+12) /* Instructions */
12:06:42 <cpressey> wob_jonas: Would you be willing to settle for it being a DSL embedded in Haskell?
12:07:51 <wob_jonas> cpressey: I don't know, haskell being typed could be a problem. I'd like some basis of combinators (not necessarily SKI specifically) to be trivial to translate into it
12:08:09 <int-e> cpressey: The point I had in mind with BLC is that it's specified with a binary stream as input; the program is parsed from that input and the remaining input is passed to that program, so it already has "call with current input" built in.
12:08:10 <wob_jonas> without getting type errors
12:08:12 <cpressey> I wrote a SKI interpreter in Haskell once but I've never been confident it's correct because I've never found a good collection of tests cases for SKI terms
12:09:01 <wob_jonas> yeah, nobody writes actual programs for those
12:09:23 <wob_jonas> perhaps some of the ones from the unlambda quine competition could help, but they use side effects so depend on the order of evaluation
12:09:25 <Taneb> I used to occasionally
12:09:25 <int-e> (Also, any concrete definition of (a) Kolmogorov complexity will probably have the same feature.)
12:10:01 <int-e> cpressey: And I know I'm going off a tangent.
12:12:57 <cpressey> int-e: Maybe not really. Like a TM, you don't really *need* to have input. You start off writing the data you want, onto the tape (or in this case, with a function (S->S) that returns a constant S)
12:14:13 <int-e> That's not really good for information complexity... there's too much inherent redundancy in Turing Machines themselves.
12:14:17 <cpressey> There was another tanget I was thinking about similar to this regarding infinite programs, and maybe Turing machines with fixed-length input tapes are not a bad idea
12:14:39 <int-e> So you're better off with just a string that you split into program and input.
12:15:26 <int-e> (Compared to embedding the input into the program, which may blow up depending on the model of computation.)
12:17:11 <int-e> I mean one of the properties that you want off Kolmogorov complexity is that the formalism you base it on only changes it by O(1).
12:18:21 <int-e> (Formalism = a concrete model of computation, which should be Turing-complete.)
12:27:22 <cpressey> What's to stop the program from treating the input as another program though
12:37:10 <cpressey> I think my thought was, the finite control of a TM is defined to be finite, so if you map your program to a TM, you know it's finite and that's fine. You can also map your program to a finite string and feed it as input to a TM, *but*...
12:37:56 <cpressey> ...a TM reads its input from its tape, and its tape is *not* finite, so if you somehow put an infinite program there, it would not reject that.
12:38:16 <cpressey> Or I mean, if it does not ever stop reading that input, you can't really blame it.
12:39:00 <int-e> Sure, that will happen.
12:41:24 <cpressey> I don't really remember what the implications of this that I cared about were, now.
12:51:18 <cpressey> Overall it has to do with "infinite programs" and whether you accept them or not. Is "the decimal expansion of sqrt(2)+sqrt(3)" an infinite program?
12:51:38 <cpressey> It's an algebraic number, I can communicate it finitely
12:51:57 -!- doesthiswork has joined.
12:52:01 <cpressey> If the interpreter wants to compute decimal digits of it to find out what to do next, that's its perogative
12:52:22 <int-e> it's an infinite string with finite description complexity
12:52:32 <cpressey> int-e: like most TMs
12:52:41 <cpressey> well, "most"
12:52:49 <cpressey> Chaitin's omega notwithstanding
12:52:54 <int-e> I see a type mismatch
12:53:09 <int-e> a) TMs are finite. b) TMs are not strings.
12:53:39 <int-e> Anyway, Chaitin only allows finite programs.
12:53:56 <cpressey> Usually when I write down a TM it's a string
12:54:24 <cpressey> BUt I think there's some confusion here
12:54:52 <int-e> And I think we're in a corner where it's valuable to be more precise.
12:55:24 <cpressey> OK. You can identify TMs with their finite descriptions. You can also identify them with the (sometimes) infinite string they write on their tape when you run them.
12:56:21 <int-e> So... the picture I have in mind is this: a) we have a Turing-complete model of computation. b) we have a prefix-free encoding of programs for that model. c) we consider strings p i where p is a program and i is the program's input.
12:57:14 <int-e> We also want all programs to be encoded so by König's lemma there are infinite strings that do not have a program as a prefix. Those are not infinite programs; they're just garbage :P
12:58:52 <int-e> (And all this happens over some fixed finite alphabet. {0,1} is a neat choice.)
12:59:14 <esowiki> [[ACL]] https://esolangs.org/w/index.php?diff=64924&oldid=64908 * Hanzlu * (+119)
12:59:28 * int-e is glossing over details like the map from the strings p to programs being effectively computable...
13:00:04 <wob_jonas> cpressey: how would the latter work? there are different turing machines that write different strings when they get no input
13:00:37 <wob_jonas> huh... why am I yellow now?
13:01:49 <wob_jonas> oh I see, I'm yellow in webchat, but still bluish gray in the esolangs.org logs
13:01:57 -!- wob_jonas has changed nick to lob_jonas.
13:02:42 <cpressey> wob_jonas: I only mean "for each TM you can look at the infinite string it produces" - I mean "sqrt(2)+sqrt(3)" and "sqrt(3)+sqrt(2)" generate the same infinite string of digits too
13:03:12 <lob_jonas> cpressey: yeah, but you said "identify"
13:03:15 <cpressey> Given the infinite string, you don't know which of those finite strings produced it.
13:03:31 <cpressey> lob_jonas: fine, I didn't mean identify, I'm sorry
13:03:42 <int-e> Yeah, identifying TMs with their output lands you in Rice territory.
13:03:49 <cpressey> wa
13:04:00 <cpressey> "associate"?
13:04:06 <cpressey> ->, not <->
13:04:25 <cpressey> I don't think it matters because I don't think I'm talking about what int-e is talking about :)
13:04:28 <lob_jonas> I prefer => or |> or |-> for that
13:04:37 <lob_jonas> but admittedly some programming languages abuse -> for this
13:04:48 <lob_jonas> at least Haskell is prudent enough to put a backslash before
13:04:54 <lob_jonas> :> also works
13:05:44 <int-e> cpressey: nobody wrote "associate"??
13:05:55 <int-e> cpressey: I mean except for you, and now me...
13:06:06 <cpressey> int-e: I was trying to think of a word that would have been better for me to use, than "identify"
13:06:20 <int-e> ah.
13:06:41 <int-e> Yeah I probably wouldn't have objected to that :)
13:10:00 <cpressey> In a sense, yhe only infinite programs you need to worry about, are those that are uncomputable, because if they're computable, you can devise a TM to compute them, and write that TM as a finite string, and there's your finite program.
13:11:25 <cpressey> "In a sense" probably includes "If you're not also worrying about Kolmogorov complexity" in its meaning here
13:17:27 <lob_jonas> `? in a sense
13:17:28 <HackEso> in a sense? ¯\(°​_o)/¯
13:19:32 <int-e> I guess in a wisdom context we need to clarify which of the 5 senses we're talking about.
13:20:27 <Taneb> Balance
13:20:35 <Taneb> Right and wrong
13:24:19 <lob_jonas> `card-by-name Balance
13:24:20 <HackEso> Balance \ 1W \ Sorcery \ Each player chooses a number of lands they control equal to the number of lands controlled by the player who controls the fewest, then sacrifices the rest. Players discard cards and sacrifice creatures the same way. \ A-R, B-R, U-R, RV-R, 4E-R, EMA-M, VMA-M, ME4-R, V09-M \ \ Balance of Power \ 3UU \ Sorcery \ If target opponent has more cards in hand than you, draw cards equal to the difference. \ P1-R, P3K-R, 8ED-R
13:25:55 <lob_jonas> "Right and wrong" is probably a future split spell
13:31:27 <int-e> . o O ( "Wrong, instant, 1B, choose one: counter target "Right" spell, or put a -1/-1 counter on target creature." / "Right, instant, 1W: Choose one: counter target "Wrong" spell, or: Put a +1/+1 counter on target creature." -- probably unbalanced, but what do you think of the mutual counter spell idea? )
13:32:06 <esowiki> [[ACL]] https://esolangs.org/w/index.php?diff=64925&oldid=64924 * Hanzlu * (+48)
13:33:49 <int-e> (It's not meant to be useful either, just for flavor.)
13:35:03 <lob_jonas> int-e: unbalanced in what sense? just the +1/+1 counter instant half alone would cost (W/G) alone, the other half would cost (B/R), making it a split card makes it a bit better because it gives you the choice, but not so much as to make it too cheap for 1B and 1W
13:35:26 <lob_jonas> and I think the Right would have to be the left half, strange as it may sound
13:35:44 <int-e> lob_jonas: I wasn't making a split card though.
13:35:49 <lob_jonas> oh
13:35:54 <lob_jonas> then they're definitely overpriced
13:35:58 <lob_jonas> `card-by-name Scar
13:35:59 <HackEso> Scar \ (b/r) \ Instant \ Put a -1/-1 counter on target creature. \ SHM-C \ \ Scarab Feast \ B \ Instant \ Exile up to three target cards from a single graveyard. \ Cycling {B} ({B}, Discard this card: Draw a card.) \ AKH-C \ \ Scarab of the Unseen \ 2 \ Artifact \ {T}, Sacrifice Scarab of the Unseen: Return all Auras attached to target permanent you own to their owners' hands. Draw a card at the beginning of the next turn's upkeep. \ AI-U \ \ Scarblade
13:36:35 <lob_jonas> `card-by-name Battlegrowth
13:36:36 <HackEso> Battlegrowth \ G \ Instant \ Put a +1/+1 counter on target creature. \ MRD-C
13:36:43 <lob_jonas> wait, isn't there one that costs (W/G)?
13:37:24 <lob_jonas> anyway
13:37:35 <lob_jonas> `card-by-name Burst of Strength
13:37:36 <HackEso> Burst of Strength \ G \ Instant \ Put a +1/+1 counter on target creature and untap it. \ GTC-C
13:37:48 <lob_jonas> just G is clearly not too cheap
13:37:56 <int-e> lob_jonas: I really wanted 'wrong: counter "right" spell' 'right: counter "wrong" spell' - which means they have to be instants. But the cards need another effect to have any use at all.
13:37:58 <lob_jonas> probably could be done for (W/G)
13:38:23 <lob_jonas> int-e: yeah, but I still think those names would be reserved for a split spell unless that's proven impossible
13:38:33 <int-e> I have no clue about balancing in M:tG; I have never played it seriously and I have not played it in the past 8 years.
13:38:45 <lob_jonas> such nice short names are in a short supply for M:tG, because it wants to live for a long time
13:39:04 <esowiki> [[Talk:Deadfish Joust]] M https://esolangs.org/w/index.php?diff=64926&oldid=64919 * A * (+152)
13:39:10 <lob_jonas> the Erase (Not the Urza's Legacy One) card makes fun of that
13:40:09 <cpressey> https://esolangs.org/wiki/Sequential_tag_system is (I guess) the reference point for what I was saying. I think that explanation for why infinite programs are justified is more than a little muddy.
13:40:23 <int-e> (I also arbitrarily thought that "right" should be a white spell and "wrong" a black one :P)
13:40:54 <lob_jonas> int-e: well, it certainly makes sense that the white spell puts the +1/+1 counter and the black spell puts the -1/-1 counters
13:41:58 <lob_jonas> int-e: if you want two opposing spells that counter each other, I'd like to point to the ones from Alpha:
13:42:03 <lob_jonas> `card-by-name Blue Elemental Blast
13:42:05 <HackEso> Blue Elemental Blast \ U \ Instant \ Choose one -- \ • Counter target red spell. \ • Destroy target red permanent. \ A-C, B-C, U-C, RV-C, 4E-C, A25-U, ME4-U
13:42:05 <lob_jonas> `card-by-name Red Elemental Blast
13:42:07 <HackEso> Red Elemental Blast \ R \ Instant \ Choose one -- \ • Counter target blue spell. \ • Destroy target blue permanent. \ A-C, B-C, U-C, RV-C, 4E-C, A25-U, ME4-U
13:42:40 <lob_jonas> there's also White Knight and Black Knight, but they don't counter
13:43:05 <int-e> lob_jonas: thanks for the example
13:44:01 <lob_jonas> countering itself doesn't happen often in black and white, which is why this pair is red and blue
13:47:12 <esowiki> [[Deadfish Joust]] https://esolangs.org/w/index.php?diff=64927&oldid=64905 * A * (-41)
13:47:50 <esowiki> [[Deadfish Joust]] M https://esolangs.org/w/index.php?diff=64928&oldid=64927 * A * (+16)
13:50:37 -!- ais523 has joined.
13:52:36 <esowiki> [[Talk:Sequential tag system]] N https://esolangs.org/w/index.php?oldid=64929 * Chris Pressey * (+698) Created page with "== Trying to make this more precise == Here are some subsets of the set of all sequential tag systems: * Sequential tag systems that a cyclic tag system can be translated int..."
13:58:27 <esowiki> [[Deadfish Joust]] M https://esolangs.org/w/index.php?diff=64930&oldid=64928 * A * (-294) /* Instructions in deadfish Joust */
14:04:29 <esowiki> [[Deadfish Joust]] https://esolangs.org/w/index.php?diff=64931&oldid=64930 * A * (+749)
14:04:42 <esowiki> [[Deadfish Joust]] M https://esolangs.org/w/index.php?diff=64932&oldid=64931 * A * (-2) /* Implementation */
14:15:20 <cpressey> If you have a language that accepts infinite programs and you don't restrict that set of programs to those that have finite descriptions (as e.g. TMs that generate them) you're... not in a place where it makes sense to write TC proofs anymore.
14:17:49 <cpressey> Some CAs need infinite initial configurations to be shown TC. In practice those configurations always have finite descriptions, as far as I have ever seen
14:18:55 <cpressey> I suspect you want an even stronger constraint than "finite" but again, I don't think I've seen any which need extremely complex initial configurations
14:19:14 <cpressey> Sequential tag systems that are expansions of cyclic tag systems are not very complex at all
14:23:12 <cpressey> I imagine anyone who objects to a TC proof by that method, would also object to the very idea of a language that allows infinite programs
14:23:55 <cpressey> Or at least, if they don't, I'd like to hear more about their philosophical views of computation
14:27:28 <cpressey> ais523: This is what I've been ranting about today. Well, this and second-order concatenative languages
14:29:13 <ais523> cpressey: I have something of a practical objection: people see TCness proofs based on infinite cyclic initial states and then try to use them to prove other languages TC, when those languages can only simulate finitely-nonblank initial states
14:29:47 <ais523> I've seen so many proofs that try to prove something TC via implementing rule 110 but with the space only finitely initialised…
14:30:19 <Taneb> Is it proven that rule 100 with finite initialisation is not TC?
14:30:44 <ais523> that said, there's clearly a boundary between acceptable and unacceptable initial states for infiinite programs, the main controversy is about where to put it
14:30:48 <lob_jonas> ais523: are those proofs fixable by initializing the infinite tape lazily?
14:31:06 <ais523> lob_jonas: occasionally there's an obvious way to do it, often thare isn't though
14:31:08 <ais523> *there
14:35:24 <int-e> I never liked the rule 110 proof.
14:37:53 <int-e> (To my mind the repeating pattern /extends/ the behavior of the cellular automaton in a non-trivial way, by encoding some special behavior at the boundary of the (properly) populated cells.)
14:39:14 <cpressey> Lazily initializing new cells when the finite but unbounded state needs to be expanded is a better way at looking at many languages (including CA) than saying they have infinite programs.
14:39:25 <cpressey> Imo.
14:39:43 <ais523> cpressey: fwiw, I put some of my thoughts on the matter into the form of a language: https://esolangs.org/wiki/Along_and_Across
14:41:21 <ais523> it strikes me that it's dangerous to ever say "X can't be Turing-complete" without a really good argument, and if various AaA variants were proven to be sub-TC it would help make TCness proofs using certain forms of infinite initial states more acceptable
14:42:06 <esowiki> [[Talk:Your Pillows]] N https://esolangs.org/w/index.php?oldid=64933 * Areallycoolusername * (+229) Created page with "[[User: A]], apart from this language being stack-based, how is this language based off of [[Brace For Impact]]? ~~~~"
14:42:11 <ais523> infinite initial states lead to some weirdness even in the abstract, though, e.g. they make LBAs TC by giving them access to infinite memory
14:42:20 <ais523> (but that's true even with a blank state)
14:43:02 <int-e> Is there any other standard proof technique for sub-TCness besides a) reduce to a known sub-TC language and b) solving the Halting problem?
14:43:43 <int-e> Because that seems a rather sad state of affairs.
14:43:57 <int-e> +to be
14:44:07 <ais523> int-e: I'd argue a language that searches for counterexamples to the Riemann hypothesis and does nothing else is obviously sub-TC, yet doesn't fulfil either of those conditions
14:44:31 <ais523> that said, I'm not sure why I think that way; despite being obviously sub-TC I'm not convined it's true
14:44:51 <ais523> I guess the issue is that there's no way to provide it with a program to run, even indirectly/
14:45:12 <cpressey> ais523: Then it's not even a language?
14:45:26 <cpressey> Again this seems to be outside the space where "Turing complete" even makes sense anymore
14:45:33 <lob_jonas> ais523: so another technique is to prove that there are only finitely many essentially different programs?
14:45:47 <esowiki> [[Deadfish Joust]] https://esolangs.org/w/index.php?diff=64934&oldid=64932 * A * (+138)
14:45:59 <ais523> lob_jonas: that's a good way to express my thoughts, thanks
14:46:24 <ais523> cpressey: I guess esolang design is like art, it's very hard to prove that there's /anything/ that isn't an esolang
14:46:38 <ais523> neither because it's non-esoteric nor because it isn't a language
14:46:39 <lob_jonas> as in, we have an easy way to tell which of the finitely many classes any program falls into, while we need not know what the program does
14:46:59 <ais523> lob_jonas: yes, I like that
14:47:21 <ais523> although, hmm
14:47:36 <Taneb> Some sort of contrapositive Rice's theorem?
14:47:43 <ais523> think about the language implemented by a truth-machine: it has two programs, 0 and 1, one of them halts, the other one doesn't
14:48:02 <ais523> assuming you disregard I/O, given any Turing machine program, it's equivalent to one or the other of those two programs
14:48:13 <ais523> the problem is, of course, that the compile is uncomputable
14:48:26 <lob_jonas> ais523: yes, that's why it's important that it's easy to tell which program falls into which of our classes
14:48:35 <ais523> but I think you need to assume the Church-Turing thesis to be able to say that the language is definitely sub-TC
14:48:51 <ais523> or, hmm
14:49:04 <ais523> maybe computational class equivalence is relative to the power of your compiler
14:49:19 <ais523> I can imagine a language that's TC but you can't compile into it in polynomial time
14:49:56 <ais523> (An Odd Rewriting System might be one of those!)
14:50:12 <cpressey> ais523: That's what I was talking about the other day
14:50:40 <ais523> cpressey: oh, there were several different but related issues there and I was confused about which specific one you were looking at
14:50:49 <cpressey> I tend to say "reduction" instead of "compiler"
14:50:52 <ais523> I was thinking about the >polynomial blowup in program size
14:51:04 <ais523> and thought that's what you meant too
14:51:10 <ais523> rather than the complexity of the compiler
14:51:22 <cpressey> ais523: Oh right, that's slightly different
14:51:35 <ais523> ofc, making the output too large to generate in polytime is an easy way to require a >polytime compiler, but there might be other ways
14:51:41 <esowiki> [[Talk:Your Pillows]] M https://esolangs.org/w/index.php?diff=64935&oldid=64933 * A * (+180)
14:52:41 <esowiki> [[Your Pillows]] M https://esolangs.org/w/index.php?diff=64936&oldid=64879 * A * (-25)
14:53:00 <ais523> for example, can you have a language where you need to be able to solve the subset sum problem to be able to write arbitrary programs in it?
14:53:09 <cpressey> ais523: Can you make a polynomially-expanding clock in AORS?
14:53:23 <cpressey> Obviously you can make exponential and constant-period ones
14:54:01 <esowiki> [[Your Pillows]] M https://esolangs.org/w/index.php?diff=64937&oldid=64936 * A * (+118)
14:54:23 <esowiki> [[Talk:Your Pillows]] M https://esolangs.org/w/index.php?diff=64938&oldid=64935 * A * (+14)
14:55:31 <ais523> cpressey: hmm… you can easily create a polynomially-widening bit of code, I can't see an obvious way to make that into a clock though
14:55:38 <esowiki> [[Talk:Your Pillows]] M https://esolangs.org/w/index.php?diff=64939&oldid=64938 * A * (+66)
14:56:25 <ais523> unless… what if each such section of code were single-use, and triggered a copy of itself (which had since grown a little)?
14:56:31 <ais523> maybe it is possible
14:58:47 <esowiki> [[Your Pillows]] M https://esolangs.org/w/index.php?diff=64940&oldid=64937 * A * (+0)
14:59:58 <ais523> the idea would be to start with some code that generates a static tape pattern like abaaaabbaaaaaaaaabbbbaaaaaaaaaaaaaaaabbbbbbbb… (that should be fairly easy, I think); the 'a's grow polynomially, the 'b's exponenntially
15:00:43 <esowiki> [[Talk:Your Pillows]] M https://esolangs.org/w/index.php?diff=64941&oldid=64939 * A * (-28)
15:00:44 <ais523> when receiving an oddness signal from the left, a 'b' repeats it on the next cycle, then deletes itself if it didn't see such a repeat from its left
15:02:09 <cpressey> I did manage to convince myself that a constant-period clock wouldn't work, because you at some point have more cells than the period, so need to re-use communication channels whos previous values you want to ignore, but the only operation you have is XOR, so you can't.
15:02:13 <ais523> then we have a second type of oddness signal that the 'a's use to communicate; if they see the first type of signal and it isn't immediately repeated, they all change into an alternative state that sends the second signal every cycle until they didn't see it on their left the previous cycle
15:02:48 <ais523> oh, we also need a 'c' to the left of the 'b's which generates the first sort of signal once when the second sort stops
15:03:02 <cpressey> So you need to generate "clear channels". At the same time, you don't need to generate an exponential number of them. Only linear in the number of cells, probably, or at worst n^2
15:03:09 <ais523> that produces a polynomially-growing clock but with exponentially-growing code
15:05:12 <ais523> ugh, doesn't work directly, the 'a's interfere with each others' signals
15:05:33 <ais523> you can still make it work but you need the blocks of 'a's to have exponentially-growing width too
15:05:49 <ais523> and then you might not be able to generate them fast enough
15:07:13 <ais523> AORS is really unintuitive, there are a lot of operations that seem trivial but then you try to implement them and they don't work
15:07:52 <cpressey> If the string grows expoenentially then it takes exponential time if you measure processing each character, which is probably the way you should measure it
15:08:36 <cpressey> In other news, the computational class example in AaA reminds me of the proof that the emptiness of the intersection of two CFLs is undecidable
15:08:46 <cpressey> But this is a CFL and a regular language
15:09:12 <cpressey> The intersection of a CFL and a regular language is context-free, if I am not mistaken
15:09:18 <lob_jonas> stupid question. have I ever written a python quine?
15:09:37 <ais523> lob_jonas: you're likely in a better place to answer that question than anyone esle is
15:09:49 <lob_jonas> yeah
15:09:54 <ais523> if it helps, I know that /I've/ written a python quine, but that doesn't really answer the question
15:10:08 <lob_jonas> I think I haven't, at least not a non-empty one
15:10:13 <lob_jonas> I'll fix that now
15:11:08 <ais523> most, maybe all, of my Python quines have been polyglots
15:16:04 <cpressey> ais523: Actually I think AaA is Turing-complete because mu-calculus
15:16:11 <cpressey> if you follow me
15:16:42 <ais523> I don't know the mu-calculus well enough to follow
15:16:43 <cpressey> You're searching for the smallest integer that fulfils some primitive condition.
15:17:11 <ais523> in the FSM/FSM version, I'm searching for the smallest integer whose digitis match a particular regex
15:17:48 <ais523> or, well, I'm regexing consecutive integers to produce a list of results, then trying to determine if those results match a particular regex
15:17:58 <cpressey> Sorry apparently the word "calculus" is not standard for it
15:18:09 <cpressey> https://en.wikipedia.org/wiki/%CE%9C-recursive_function
15:18:51 <cpressey> "Intuitively, minimisation seeks—beginning the search from 0 and proceeding upwards—the smallest argument that causes the function to return zero; if there is no such argument, the search never terminates."
15:19:20 <cpressey> If you add that operator to PR you get RE (i.e. it's Turing-complete)
15:19:35 <cpressey> I don't know the weakest system you could add that operator to and get something TC
15:19:45 <esowiki> [[Brace For Impact]] https://esolangs.org/w/index.php?diff=64942&oldid=64875 * Areallycoolusername * (+1436)
15:19:46 <cpressey> But I don't know of anything requiring it to be as powerful as PR
15:20:10 <lob_jonas> `python3 -cfor k in 3,1,0,0,1,2,1,0,1,1,2,1,2,1,2,1,3,1,2,1,4,1,2,1,5,1,4,1,1,5:print(('\\','\'',',','for k in 3,1,0,0,1,2,1,0,1,1,2,1,2,1,2,1,3,1,2,1,4,1,2,1,5,1,4,1,1,5:print((',')[k],end=',')')[k],end='')
15:20:13 <HackEso> for k in 3,1,0,0,1,2,1,0,1,1,2,1,2,1,2,1,3,1,2,1,4,1,2,1,5,1,4,1,1,5:print(('\\','\'',',','for k in 3,1,0,0,1,2,1,0,1,1,2,1,2,1,2,1,3,1,2,1,4,1,2,1,5,1,4,1,1,5:print((',')[k],end=',')')[k],end='')
15:21:07 <lob_jonas> let me make that a bit nicer
15:23:01 <lob_jonas> `python3 -cfor k in 3,1,0,0,1,2,1,0,1,1,2,1,2,1,2,1,3,1,2,1,4,1,4:print(('\\','\'',',','for k in 3,1,0,0,1,2,1,0,1,1,2,1,2,1,2,1,3,1,2,1,4,1,4:print((',')[k],end=str())')[k],end=str())
15:23:02 <HackEso> for k in 3,1,0,0,1,2,1,0,1,1,2,1,2,1,2,1,3,1,2,1,4,1,4:print(('\\','\'',',','for k in 3,1,0,0,1,2,1,0,1,1,2,1,2,1,2,1,3,1,2,1,4,1,4:print((',')[k],end=str())')[k],end=str())
15:23:12 <ais523> cpressey: I think it was mentioned on the talk page that what you have is basically µ-recursion which only allows one use of the µ operator
15:23:14 <ais523> `unidecode µ
15:23:14 <HackEso> ​[U+00B5 MICRO SIGN]
15:23:21 <ais523> wrong µ, sorry, the other one isn't on my keyboard
15:23:41 <ais523> that means you can have a different computational power inside and outside
15:23:43 <cpressey> well, if a while program only needs one while loop, ... ok, that's hardly the best sort of reasoning
15:23:50 <esowiki> [[Brace For Impact]] https://esolangs.org/w/index.php?diff=64943&oldid=64942 * Areallycoolusername * (+367)
15:24:10 <ais523> having only FSMs/regular languages inside the µ seems like it's a substantial cut to the power of the language
15:24:15 <cpressey> Oh, so Plokmijnuhby noticed exactly what I noticed
15:24:49 <cpressey> (but has a much cooler name than I do)
15:25:36 <cpressey> You definitely only need one minimization operation to be TC (he said without a shred of proof)
15:25:53 <ais523> actually, it's not quite the same
15:25:57 <cpressey> You search for the smallest Turing machine that does what you need and you simulate that and you're done
15:26:02 <lob_jonas> μ ?
15:26:15 <cpressey> μ !
15:26:38 <Taneb> Moo
15:26:43 <ais523> the current AaA proof doesn't work in µ-calculus with only one minimization, as you need to put the minimization itself into a loop
15:26:56 <ais523> it's more like, only one minimization is allowed in the program's /source code/ but you can put control flow around it
15:27:03 <ais523> `unidecode μ
15:27:04 <HackEso> ​[U+03BC GREEK SMALL LETTER MU]
15:27:11 <ais523> `unidecode μ
15:27:11 <HackEso> ​[U+03BC GREEK SMALL LETTER MU]
15:27:40 <ais523> if μ and µ didn't look identical I wouldn't have to unidecode them to see which was which
15:28:40 <lob_jonas> `? font
15:28:41 <HackEso> ​#esoteric bitmap fonts include: \oren\'s font http://www.orenwatson.be/fontdemo.htm , lifthrasiir's font https://github.com/lifthrasiir/unison/ , b_jonas's font http://www.math.bme.hu/~ambrus/pu/fecupboard20-c.pcf.gz , fizzie's font https://github.com/fis/rfk86/tree/master/web/font , FireFly's fonts http://xen.firefly.nu/up/fonts/
15:30:03 <ais523> I guess there's no real reason for them to /look/ different, they're just /semantically/ different (one is pronounced "m", or "mu" if alone, and one is pronounced "micro")
15:30:55 <ais523> maybe I should stop being lazy and finally upgrade my compose key to RFC 1345, even if it's a little less intuitive than the standard compose key layout
15:32:02 <lob_jonas> ais523: I think they're only historically different
15:32:47 <lob_jonas> the opposite as how the t with comma under and the t with cedilla under are now different letters when they used to be the same, the two mus are now the same but we have to support both encodings
15:35:02 <lob_jonas> and yes, that analogy makes no sense
15:36:27 <ais523> well, there's a character in CP437 which was intended to be used for both the German ß and the Greek beta…
15:36:41 <ais523> (and those don't even /look/ the same, just kind of similar, but are definitely semantically different)
15:36:59 <ais523> but the semantic difference between μ and µ is probably relevant for things like screen readers
15:37:20 <ais523> (compare "µ-architecture" to "m-architecture", for example)
15:38:21 <lob_jonas> ais523: sure, because that encoding was originally made for unchangable 256 sized character sets burned into ROM, with fonts that are 14 or 8 pixel high on a monitor, or similarly small on a printer
15:42:12 <cpressey> I once used a typewriter that had no "1" key. It was assumed you'd just use a lowercase "l" for it.
15:43:26 <lob_jonas> http://nerdlypleasures.blogspot.com/2015/04/ibm-character-fonts.html nice listing of all the original fonts
15:43:56 <lob_jonas> cpressey: sure, old typewriters were like that, no "1", no "0", no "í", no "ú", no "ű".
15:53:12 <cpressey> I can kind of imagine μ(FA(μ(CFL))) (if that's what that AaA construction is, still pretty fuzzy on that) being Turing-complete
15:53:43 <cpressey> or some construction in the vicinity of that
15:53:53 <ais523> "FA"?
15:53:59 <cpressey> FSM if you like
15:54:06 <Taneb> Football Association
15:54:08 <cpressey> (Finite Automaton)
15:54:16 -!- Sgeo__ has joined.
15:57:07 -!- Sgeo_ has quit (Ping timeout: 245 seconds).
15:57:23 <cpressey> I was going to do an esolang around something like μ(CFL), by coincidence. Haven't gotten around to it yet
15:57:59 <cpressey> There's always something more interesting on the other side of the fence
15:58:04 <cpressey> Anyway
15:58:11 <cpressey> A la prochaine.
15:58:13 -!- cpressey has quit (Quit: WeeChat 1.4).
16:02:03 <lob_jonas> `python3 -cfor k in b'2030401010201030104010505':print((chr(39),',','for k in b','2030401010201030104010505',':print((chr(39),',')[k-48],end=str())')[k-48],end=str())
16:02:07 <HackEso> for k in b'2030401010201030104010505':print((chr(39),',','for k in b','2030401010201030104010505',':print((chr(39),',')[k-48],end=str())')[k-48],end=str())
16:02:16 <lob_jonas> this one is longer, but there's something I can do with it
16:03:17 -!- xkapastel has joined.
16:17:13 <lob_jonas> `python3 -cs='1606261656265636564656563664';[print((s,'s=',';[print((s,',',chr(39))[int(k)],end=',')for k in s]',',',chr(39))[int(k)],end='')for k in s]
16:17:14 <HackEso> s='1606261656265636564656563664';[print((s,'s=',';[print((s,',',chr(39))[int(k)],end=',')for k in s]',',',chr(39))[int(k)],end='')for k in s]
16:20:14 <lob_jonas> `python3 -cs='150525154525453545453';[print((s,'s=',';[print((s,',',chr(39))[int(k)],end=str())for k in s]',',',chr(39))[int(k)],end=str())for k in s]
16:20:17 <HackEso> s='150525154525453545453';[print((s,'s=',';[print((s,',',chr(39))[int(k)],end=str())for k in s]',',',chr(39))[int(k)],end=str())for k in s]
16:20:19 <lob_jonas> even better
16:20:46 <lob_jonas> of course there would probably be much shorter ones if I didn't try this ridiculous indexing thing
16:31:29 <lob_jonas> `olist 1173
16:31:30 <HackEso> olist 1173: shachaf oerjan Sgeo FireFly boily nortti b_jonas
16:37:37 -!- lob_jonas has quit (Remote host closed the connection).
17:15:01 -!- Phantom_Hoover has joined.
17:25:15 -!- ais523 has quit (Quit: quit).
17:25:58 -!- Sgeo_ has joined.
17:29:38 -!- Sgeo__ has quit (Ping timeout: 245 seconds).
17:38:59 -!- b_jonas has joined.
17:59:47 <esowiki> [[User:Hanzlu]] https://esolangs.org/w/index.php?diff=64944&oldid=64911 * Hanzlu * (+298)
18:00:09 <esowiki> [[User:Hanzlu]] https://esolangs.org/w/index.php?diff=64945&oldid=64944 * Hanzlu * (+4)
18:13:56 -!- kolontaev has joined.
18:49:39 <kmc> shachaf: the chonky orange cat is back
18:58:34 -!- kolontaev has quit (Quit: leaving).
18:58:35 <shachaf> kmc: yay
18:58:38 <shachaf> cat
19:00:12 <b_jonas> `? cat
19:00:17 <b_jonas> `whatis cat
19:00:17 <HackEso> Cats are cool, but should be illegal.
19:00:20 <HackEso> cat(1) - concatenate files and print on the standard output \ cat(1p) - concatenate and print files \ CaT(1hackeso) - no description \ cAt(1hackeso) - no description
19:02:28 <kmc> `cat
19:02:54 <kmc> `dog
19:02:55 <HackEso> ​/srv/hackeso-code/multibot_cmds/lib/limits: line 5: exec: dog: not found
19:02:58 <HackEso> No output.
19:03:22 <b_jonas> `tomfoolery cat
19:03:23 <HackEso> A cat is an animal with four legs. It's nice to pet, especially when it's a baby cat, called a kitten. Or it's the unix "cat" command. It takes a filename (or many) and prints the contents of that (those) file(s).
19:03:55 <kmc> boringly accurate
19:06:16 <b_jonas> ``` perl -pi -e s+tp:+tps+ tmflry/wiki
19:06:17 <HackEso> No output.
19:06:22 <b_jonas> `tomfoolery wiki
19:06:23 <HackEso> The wiki is at https//esolangs.org/wiki
19:06:27 <b_jonas> argh
19:06:35 <b_jonas> ``` perl -pi -e s+tps/+tps:/+ tmflry/wiki
19:06:37 <HackEso> No output.
19:06:40 <b_jonas> `tomfoolery wiki
19:06:41 <HackEso> The wiki is at https://esolangs.org/wiki
19:06:50 -!- FreeFull has joined.
19:06:57 <b_jonas> I'd edited all the urls in the wisdome earlier, but this one fell aside
19:32:03 <b_jonas> `? right
19:32:07 <HackEso> Right is not two wrongs but three lefts.
19:38:45 <b_jonas> Right is the direction you should face towards when the baby metroid drains you, in order to be able to stand up slightly faster.
19:53:44 -!- lldd_ has joined.
19:56:10 <esowiki> [[Special:Log/newusers]] create * IAmAnIssu * New user account
19:58:16 <tswett[m]> Hey, is it feasible to calculate the first few decimal digits of Graham's number? 🤔
19:58:34 <tswett[m]> Graham's number is of the form 3^3^3^3^...
19:59:07 <tswett[m]> Calculating the first few digits entails calculating, what is it.
19:59:17 <tswett[m]> log(3^3^3^3^...) mod log(10), isn't it?
20:00:06 <esowiki> [[Esolang:Introduce yourself]] https://esolangs.org/w/index.php?diff=64946&oldid=64797 * IAmAnIssu * (+146)
20:00:43 <esowiki> [[Esolang:Introduce yourself]] https://esolangs.org/w/index.php?diff=64947&oldid=64946 * IAmAnIssu * (-5) ok then
20:01:20 <esowiki> [[Esolang:Introduce yourself]] https://esolangs.org/w/index.php?diff=64948&oldid=64947 * IAmAnIssu * (+65) I have no idea what I'm doing
20:02:42 -!- Lord_of_Life_ has joined.
20:05:43 -!- Lord_of_Life has quit (Ping timeout: 268 seconds).
20:05:47 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
20:27:47 <esowiki> [[Forget]] N https://esolangs.org/w/index.php?oldid=64949 * IAmAnIssu * (+2326) Created page with "==Forget== '''Forget''' is a stack-based language where pointers are poisonous and the interpreter doesn't do a good job of remembering non-constant values ==Syntax== Instruct..."
20:29:51 <esowiki> [[Forget]] https://esolangs.org/w/index.php?diff=64950&oldid=64949 * IAmAnIssu * (+49)
20:30:45 <esowiki> [[Language list]] https://esolangs.org/w/index.php?diff=64951&oldid=64900 * IAmAnIssu * (+13)
20:31:47 <esowiki> [[Forget]] https://esolangs.org/w/index.php?diff=64952&oldid=64950 * IAmAnIssu * (+7)
20:32:58 <esowiki> [[Forget]] https://esolangs.org/w/index.php?diff=64953&oldid=64952 * IAmAnIssu * (+183)
20:33:13 <esowiki> [[Forget]] https://esolangs.org/w/index.php?diff=64954&oldid=64953 * IAmAnIssu * (+1)
20:33:34 <esowiki> [[User:Areallycoolusername]] https://esolangs.org/w/index.php?diff=64955&oldid=64560 * Areallycoolusername * (+23)
20:37:12 <esowiki> [[Language list]] https://esolangs.org/w/index.php?diff=64956&oldid=64951 * Areallycoolusername * (+23) /* B */
20:38:13 <esowiki> [[Brace For Impact]] https://esolangs.org/w/index.php?diff=64957&oldid=64943 * Areallycoolusername * (+0) /* Turing complete proof */
20:45:34 <esowiki> [[Truth-machine]] https://esolangs.org/w/index.php?diff=64958&oldid=64859 * Areallycoolusername * (+136)
20:46:08 <esowiki> [[Truth-machine]] https://esolangs.org/w/index.php?diff=64959&oldid=64958 * Areallycoolusername * (+2) /* Brace For Impact */
20:46:15 <esowiki> [[Truth-machine]] https://esolangs.org/w/index.php?diff=64960&oldid=64959 * Areallycoolusername * (+1) /* Brace For Impact */
20:54:32 -!- lldd_ has quit (Quit: Leaving).
21:04:38 -!- Sgeo_ has quit (Ping timeout: 245 seconds).
21:42:12 <esowiki> [[Jussef Swissen]] https://esolangs.org/w/index.php?diff=64961&oldid=64617 * Areallycoolusername * (-20)
21:48:39 <esowiki> [[Brace For Impact]] https://esolangs.org/w/index.php?diff=64962&oldid=64957 * Areallycoolusername * (+104) Actually gave a program
21:50:26 <esowiki> [[Brace For Impact]] https://esolangs.org/w/index.php?diff=64963&oldid=64962 * Areallycoolusername * (+110) /* Turing complete Proof */
22:03:29 <esowiki> [[Brace For Impact]] https://esolangs.org/w/index.php?diff=64964&oldid=64963 * Areallycoolusername * (+671)
22:03:39 <esowiki> [[Brace For Impact]] https://esolangs.org/w/index.php?diff=64965&oldid=64964 * Areallycoolusername * (+1) /* = Hello World Program */
22:23:47 -!- Sgeo has joined.
22:30:05 -!- dog_star_ has joined.
22:35:41 -!- fungot` has joined.
22:37:20 -!- dog_star has quit (*.net *.split).
22:37:20 -!- fungot has quit (*.net *.split).
22:39:49 <esowiki> [[User talk:A]] https://esolangs.org/w/index.php?diff=64966&oldid=64892 * Areallycoolusername * (+629)
22:40:15 <shachaf> kmc: chonky orange cats are good luck
22:41:27 <kmc> yes
22:41:29 <kmc> probably
22:41:30 <kmc> aren't all cats
22:43:15 <shachaf> that too
22:49:38 -!- Phantom_Hoover has quit (Ping timeout: 245 seconds).
23:26:40 -!- b_jonas has quit (Quit: leaving).
23:37:47 <tswett[m]> I wonder if there are any rational functions that are Turing-complete when iterated.
23:38:45 <tswett[m]> A piecewise affine function R*R -> R*R is Turing-complete when iterated. You can use a real number as a stack plus a bit of finite state, and two stacks and finite state are enough to make a Turing machine.
23:39:24 <tswett[m]> To be clear, I mean rational functions that are Turing-complete when iterated on the real numbers.
23:39:30 <tswett[m]> Though the same question for complex numbers is also interesting.
23:42:05 <tswett[m]> I guess it's almost certainly easier to make a computer by iterating on the complex numbers rather than the real numbers.
23:42:46 <tswett[m]> Is the Mandelbrot set Turing-complete? Can you convert a Turing machine into a complex number such that the complex number escapes if and only if the Turing machine halts?
←2019-07-31 2019-08-01 2019-08-02→ ↑2019 ↑all