00:03:29 -!- variable has quit (Ping timeout: 276 seconds).
00:03:56 -!- tromp has quit (Ping timeout: 244 seconds).
00:08:38 -!- nfd9001 has joined.
00:13:03 -!- LKoen has quit (Quit: “It’s only logical. First you learn to talk, then you learn to think. Too bad it’s not the other way round.”).
00:18:16 -!- erkin has quit (Quit: Ouch! Got SIGIRL, dying...).
00:31:00 -!- variable has joined.
00:34:21 -!- trout has quit (Ping timeout: 240 seconds).
00:39:15 -!- tromp has joined.
00:41:44 -!- Phantom_Hoover has quit (Read error: Connection reset by peer).
00:44:09 -!- tromp has quit (Ping timeout: 264 seconds).
00:51:17 -!- XorSwap has joined.
00:54:54 -!- nfd9001 has quit (Ping timeout: 260 seconds).
01:03:03 -!- trout has joined.
01:05:53 -!- variable has quit (Ping timeout: 276 seconds).
01:08:19 -!- brandonson has quit (Ping timeout: 260 seconds).
01:09:43 -!- brandonson has joined.
01:32:55 -!- tromp has joined.
01:34:06 -!- sftp has joined.
01:34:22 -!- variable has joined.
01:37:21 -!- tromp has quit (Ping timeout: 240 seconds).
01:37:44 -!- trout has quit (Ping timeout: 276 seconds).
01:42:28 <esowiki> [[BF instruction minimalization]]  https://esolangs.org/w/index.php?diff=56686&oldid=56678 * A * (-117) /* Good news */
02:02:11 <esowiki> [[User talk:A]]  https://esolangs.org/w/index.php?diff=56687&oldid=56684 * A * (+60) /* Turing-completeness */
02:05:23 -!- trout has joined.
02:08:56 -!- variable has quit (Ping timeout: 276 seconds).
02:12:39 <esowiki> [[Special:Log/upload]] upload  * A *  uploaded "[[File:Brainloller Truth machine.gif]]"
02:14:07 <esowiki> [[Truth-machine]]  https://esolangs.org/w/index.php?diff=56689&oldid=56601 * A * (+61) /* brainfunct */
02:22:42 -!- olsner has quit (Ping timeout: 260 seconds).
02:26:17 -!- tromp has joined.
02:28:30 -!- olsner has joined.
02:28:43 -!- sebbu2 has joined.
02:30:08 -!- sebbu has quit (Ping timeout: 256 seconds).
02:30:40 -!- tromp has quit (Ping timeout: 244 seconds).
02:36:26 -!- variable has joined.
02:40:08 -!- trout has quit (Ping timeout: 276 seconds).
02:42:21 -!- olsner has quit (Ping timeout: 240 seconds).
02:49:38 -!- olsner has joined.
03:02:04 -!- olsner has quit (Ping timeout: 260 seconds).
03:05:49 <esowiki> [[Shorten your Brainfuck code]]  https://esolangs.org/w/index.php?diff=56690&oldid=56474 * A * (+502) /* An improvement */
03:07:36 -!- trout has joined.
03:10:41 -!- variable has quit (Ping timeout: 276 seconds).
03:14:37 -!- trout has quit (Quit: /dev/null is full).
03:14:43 -!- olsner has joined.
03:19:33 -!- olsner has quit (Ping timeout: 256 seconds).
03:24:19 -!- variable has joined.
03:41:27 -!- variable has quit (Quit: Found 1 in /dev/zero).
03:48:37 -!- olsner has joined.
03:52:14 <esowiki> [[Shorten your Brainfuck code]]  https://esolangs.org/w/index.php?diff=56691&oldid=56690 * A * (+210) /* Explanation */
04:09:50 <esowiki> [[Truth-machine]]  https://esolangs.org/w/index.php?diff=56692&oldid=56689 * A * (+86) /* brainfuck */
04:12:19 <esowiki> [[Truth-machine]]  https://esolangs.org/w/index.php?diff=56693&oldid=56692 * A * (-86) /* brainfuck */
04:12:51 -!- tromp has joined.
04:14:19 <esowiki> [[Truth-machine]]  https://esolangs.org/w/index.php?diff=56694&oldid=56693 * A * (+76) /* brainfuck */
04:17:06 -!- tromp has quit (Ping timeout: 244 seconds).
04:35:50 <esowiki> [[Special:Log/upload]] upload  * A *  uploaded "[[File:Shorer Brainloller Truth Machine.gif]]"
04:35:51 <esowiki> [[Special:Log/upload]] overwrite  * A *  uploaded a new version of "[[File:Shorer Brainloller Truth Machine.gif]]"
04:36:54 <esowiki> [[Truth-machine]]  https://esolangs.org/w/index.php?diff=56697&oldid=56694 * A * (+80) /* Brainloller */
04:37:33 <esowiki> [[Special:Log/upload]] upload  * A *  uploaded "[[File:Shorter Brainloller Truth machine.gif]]"
04:39:00 <esowiki> [[Special:Log/upload]] overwrite  * A *  uploaded a new version of "[[File:Shorter Brainloller Truth machine.gif]]"
05:06:58 -!- tromp has joined.
05:11:27 -!- tromp has quit (Ping timeout: 240 seconds).
05:51:14 <zzo38> Probably the duplicate file "Shorer Brainloller Truth Machine.gif" should be deleted. (Converting to PNG and avoiding the dithering, is also good to have)
06:04:05 -!- variable has joined.
06:29:17 -!- tromp has joined.
06:33:51 -!- tromp has quit (Ping timeout: 240 seconds).
06:37:20 -!- trout has joined.
06:39:44 -!- variable has quit (Ping timeout: 265 seconds).
07:07:35 -!- tromp has joined.
07:08:24 -!- variable has joined.
07:11:11 -!- trout has quit (Ping timeout: 276 seconds).
07:12:54 -!- XorSwap has quit (Ping timeout: 260 seconds).
07:39:13 -!- trout has joined.
07:42:23 -!- variable has quit (Ping timeout: 276 seconds).
08:01:05 -!- imode has quit (Ping timeout: 248 seconds).
08:06:47 -!- nfd9001 has joined.
08:09:53 -!- variable has joined.
08:13:35 -!- trout has quit (Ping timeout: 276 seconds).
08:33:13 -!- AnotherTest has joined.
08:41:55 -!- trout has joined.
08:44:47 -!- variable has quit (Ping timeout: 276 seconds).
09:13:41 -!- variable has joined.
09:16:20 -!- trout has quit (Ping timeout: 265 seconds).
09:17:06 -!- SopaXorzTaker has joined.
09:44:25 -!- trout has joined.
09:47:50 -!- variable has quit (Ping timeout: 276 seconds).
09:58:36 -!- sebbu has joined.
10:00:04 -!- sebbu2 has quit (Ping timeout: 256 seconds).
10:15:33 -!- variable has joined.
10:19:02 -!- trout has quit (Ping timeout: 276 seconds).
10:26:19 -!- Phantom_Hoover has joined.
10:47:17 -!- trout has joined.
10:50:14 -!- variable has quit (Ping timeout: 276 seconds).
11:11:20 -!- S_Gautam has joined.
11:17:55 -!- variable has joined.
11:21:31 -!- trout has quit (Ping timeout: 265 seconds).
11:49:07 -!- trout has joined.
11:52:38 -!- variable has quit (Ping timeout: 276 seconds).
11:57:01 -!- sebbu2 has joined.
11:58:30 -!- sebbu has quit (Ping timeout: 256 seconds).
12:20:12 -!- variable has joined.
12:23:23 -!- trout has quit (Ping timeout: 265 seconds).
12:48:31 -!- Phantom_Hoover has quit (Ping timeout: 265 seconds).
12:52:19 -!- trout has joined.
12:55:17 -!- variable has quit (Ping timeout: 265 seconds).
13:16:00 -!- aloril__ has joined.
13:18:26 -!- aloril_ has quit (Ping timeout: 276 seconds).
13:20:57 -!- S_Gautam has quit (Quit: Connection closed for inactivity).
13:23:10 -!- variable has joined.
13:23:32 -!- erkin has joined.
13:26:53 -!- trout has quit (Ping timeout: 276 seconds).
13:27:27 -!- S_Gautam has joined.
13:29:21 -!- SopaXorzTaker has quit (Ping timeout: 240 seconds).
13:30:06 -!- Phantom_Hoover has joined.
13:33:42 -!- SopaXorzTaker has joined.
13:48:05 -!- SopaXT has joined.
13:49:03 -!- SopaXorzTaker has quit (Ping timeout: 244 seconds).
13:53:34 -!- Phantom_Hoover has quit (Read error: Connection reset by peer).
13:54:52 -!- trout has joined.
13:56:14 -!- SopaXT has changed nick to SopaXorzTaker.
13:58:05 -!- variable has quit (Ping timeout: 276 seconds).
14:27:31 -!- variable has joined.
14:30:21 -!- trout has quit (Ping timeout: 240 seconds).
14:32:17 -!- LKoen has joined.
14:57:49 -!- trout has joined.
15:01:47 -!- variable has quit (Ping timeout: 276 seconds).
15:29:47 -!- variable has joined.
15:32:59 -!- trout has quit (Ping timeout: 276 seconds).
16:01:03 -!- trout has joined.
16:03:47 -!- variable has quit (Ping timeout: 265 seconds).
16:13:23 -!- ais523 has joined.
16:20:55 -!- imode has joined.
16:25:51 <ais523> int-e: imode: re efficiency of tarpits, Minsky machines are inherently slow if you execute them a step at a time but tend to be fairly easy to optimise
16:26:11 <ais523> meanwhile, Turing machines are missing a capability that most implementations of Turing machines in lower-level languages have: the ability to insert and delete tape elements
16:26:40 <ais523> so a Minsky machine is probably going to be more efficient than a Turing machine if you have a good optimiser
16:26:48 <ais523> I was working on one a while back but never finisehd it
16:31:16 <imode> ais523: my question is, to do anything useful, you need to use godel numbering.
16:31:26 <imode> this means I need arbitrarily large numbers.
16:31:54 <ais523> I think any language needs arbitrarily large data structures
16:32:03 <ais523> numbers are a good choice for a tarpit because they're so flexible
16:32:18 <imode> right, but what does it buy me?
16:32:30 <ais523> the ability to treat a number as an opaque object
16:32:47 <ais523> you can't really do that with, say, a tape section in a Turing machine, you need to know things about its structure and the like
16:33:00 -!- variable has joined.
16:33:04 <ais523> with numbers, you can just store them inside other numbers using exponents of primes or whatever
16:33:28 <ais523> it's massively inefficient if you look at the size of the numbers, but a sufficiently smart compiler can reverse that and decompose them back into the actual data structures
16:33:29 <imode> what does that buy you practically, though? it also relies on arithmetic.
16:34:07 <ais523> well, the simplest tarpits we know of either use numbers directly to store data, or else counts of things to store data (which is very comparable to using numbers)
16:34:11 <imode> I think I'd rather just work on strings of symbols. if I have to build something "sufficiently smart" to hack around the inefficiencies of the automata/model I'm working with...
16:34:33 <ais523> apart from maybe cyclic tag, which arguably uses strings
16:34:33 <int-e> ais523: So basically you'd be working with a stack machine then?
16:34:39 <int-e> (multi-stack machine that is)
16:35:15 <ais523> int-e: right, nearly always counter-machine tarpits, the TC proof starts by implementing a stack machine (or another counter machine that implements a stack machine, etc.)
16:35:47 <ais523> imode: well, again looking at tarpits, they tend to have an (implicit or explicit) data pointer, which means that dealing with a string has similar performance properties to dealing with a number
16:35:51 -!- trout has quit (Ping timeout: 240 seconds).
16:35:54 <ais523> as you have to move the pointer along it to accomplish anything
16:36:14 <imode> right but they admit to a mechanical representation.
16:36:24 <imode> one discrete location to the next.
16:36:45 <ais523> a number's just a string of digits, though, right?
16:37:15 <ais523> the only real difference between a string and a number is that the string enforces what base it's in, and a number doesn't inherently have opinions on that
16:40:23 -!- imode1 has joined.
16:40:24 -!- imode1 has quit (Read error: Connection reset by peer).
16:40:27 -!- imode has quit (Ping timeout: 240 seconds).
16:46:00 -!- XorSwap has joined.
17:04:32 -!- trout has joined.
17:07:53 -!- variable has quit (Ping timeout: 276 seconds).
17:17:14 -!- XorSwap has quit (Ping timeout: 260 seconds).
17:18:56 -!- XorSwap has joined.
17:21:29 -!- tromp has quit (Remote host closed the connection).
17:27:33 <esowiki> [[Special:Log/delete]] delete  * Ais523 *  deleted "[[File:Shorer Brainloller Truth Machine.gif]]": Duplicated file: this is the unused copy out of the two; both were uploaded by the same user at about the same time
17:29:42 -!- tromp has joined.
17:35:39 -!- variable has joined.
17:38:51 -!- trout has quit (Ping timeout: 240 seconds).
17:41:18 -!- tromp has quit (Remote host closed the connection).
18:05:52 -!- tromp_ has joined.
18:07:17 -!- trout has joined.
18:07:50 -!- LKoen has quit (Remote host closed the connection).
18:10:17 -!- variable has quit (Ping timeout: 276 seconds).
18:27:07 -!- imode has joined.
18:27:16 <imode> ais523: sorry I dropped out earlier, lemme review the logs.
18:27:24 <imode> damn cell service.
18:37:42 -!- tromp_ has quit (Remote host closed the connection).
18:37:50 <imode> ais523: right, but when I consider writing an algorithm for dealing with structures like adjacency matrices, 2D arrays, and other structures, I don't think "wow, that could be represented as a number", I think of the transformations required to work on parts of the structure.
18:38:15 -!- variable has joined.
18:38:16 <imode> I guess I don't see how transformations via arithmetic are somehow more suitable than just simple string substitutions.
18:39:03 <imode> especially when you need glorified bignums to do it..
18:39:08 <ais523> I guess I like the transformations to be built out of the smallest building blocks possible, because it makes them more general and places fewer assumptions about what they can be used for
18:39:25 <imode> smallest building blocks possible? what about things like thue?
18:39:34 <ais523> what about things like fractran?
18:39:49 <imode> based on arbitrary arithmetic operations.
18:39:54 <ais523> that's basically "Thue for numbers" and is more general/elegant (a Fractran program will normally be shorter than a Thue program for the same thing)
18:40:10 <imode> I'm not sure how you can say that unless you have an example.
18:40:27 <imode> fractran is multiset rewriting, not string rewriting.
18:40:45 <imode> afk.
18:41:34 <ais523> Thue is very bad at moving data from one place to another because the use of a string inherently gives the data locations
18:42:08 <ais523> that said, I don't have a concrete example of Fractran being golfier than Thue because few people have tried to golf either, it's more an educated guess
18:42:08 -!- trout has quit (Ping timeout: 276 seconds).
18:42:36 <ais523> a Fractran self-interpreter is pretty short, though, and a Thue self-interpreter isn't even possible unless you limit the alphabet a bit, in which case the size is at least quadratic in the size of the alphabet
18:56:09 -!- tromp has joined.
19:00:57 -!- imode has quit (Ping timeout: 264 seconds).
19:03:08 -!- imode has joined.
19:03:26 <imode> ais523: I'm actually working on that... by using special prefixes.
19:04:33 -!- lambdabot has quit (Remote host closed the connection).
19:05:44 -!- int-e has quit (Quit: leaving).
19:06:53 <imode> I don't think that giving data a location is a bad thing. in fact I think it as required in order to... do useful things. you're going to be doing the same thing with FRACTRAN.
19:07:02 <imode> only you're just wrapping it up in a sequence of arithmetic options.
19:07:23 -!- lambdabot has joined.
19:08:00 <ais523> well, it's about visibility
19:08:04 <ais523> in Fractran, the data is just kind-of there
19:08:08 <ais523> you don't have to move it to the right place first
19:08:24 <imode> but you're going to end up doing that anyway. I get that you strip ordering but..
19:08:32 -!- LKoen has joined.
19:10:15 <ais523> it's amazing how much more efficient a few global variables can make a program
19:10:24 -!- trout has joined.
19:11:33 <imode> if you really wanna convince me, translate this into FRACTRAN: https://ptpb.pw/qrUV/text
19:12:30 <imode> it's my variant of thue, and I have an interpreter for it. I'd be interested to see how you'd do it with a queue as well.
19:12:50 <imode> or this, which is a pseudo-drawing program: https://ptpb.pw/vO8Q/text
19:12:51 -!- variable has quit (Ping timeout: 240 seconds).
19:13:56 <ais523> that first one is, what, unary RPN?
19:14:14 <imode> yup.
19:14:21 <imode> but it parses a command set.
19:14:24 <ais523> I might have a go later, there are more important things I'm supposed to be doing first
19:14:29 <ais523> also, it's not parsing
19:14:39 <ais523> you're using Thue tokens directly as commands
19:14:48 <imode> pedantic, aren't we.
19:15:22 <ais523> nah, it's relevant here, because it's important for getting the equivalence between the two programs right
19:15:43 <imode> that doesn't disqualify the fact that you have to.. do that.
19:16:16 <ais523> imode: you'd have to do that in either direction!
19:16:36 <ais523> define how the I/O works, that is
19:18:14 <imode> right, so "given a sequence of commands, simulate a stack machine with addition and subtraction."
19:18:29 <ais523> yep
19:19:58 -!- int-e has joined.
19:20:04 <imode> I'd like to see how it ends up being... so-called better.
19:20:17 <imode> it's not hard to reason about these transformations.
19:20:30 <imode> but I cannot imagine what it's like in multiset rewriting systems like FRACTRAN.
19:21:10 <ais523> come to think of it I'd imagine that program fits Thue very well because it uses exactly two stacks in a way that doesn't require an extra encoding layer
19:21:19 <ais523> if you were trying to implement a TC language (i.e. program plus /two/ stacks) it'd be a lot messier
19:21:32 <imode> workin' on that.
19:22:16 <imode> planning on having a "label" stack. on a return, seek back to the return stack, fetch a label, and seek forward until you hit your label.
19:22:59 <imode> that's not even the only way to do it. I like the way you can use "signals" to carry information.
19:23:05 -!- XorSwap has quit (Quit: the creeping crawling chaos will return.).
19:26:21 -!- SopaXorzTaker has quit (Remote host closed the connection).
19:28:22 <imode> I'm also working on a preprocessing pass that'll add some additional features that makes the language a little easier to use. for example, the addition of "stateful strings" indicated by prefixes on every symbol. so certain rules only apply to symbols prefixed with a given "state".
19:29:37 <esowiki> [[Special:Log/upload]] upload  * Zzo38 *  uploaded "[[File:Brainloller Helloworld.png]]": Small version of Brainloller_Helloworld.gif
19:29:49 <int-e> aaaaaaaaargh.
19:30:41 <int-e> (colors)
19:31:08 <imode> rainbow.
19:32:00 <esowiki> [[Brainloller]]  https://esolangs.org/w/index.php?diff=56701&oldid=56673 * Zzo38 * (+37) 
19:33:00 <int-e> imode: I usually hide in an attempt to keep what is left of my sanity.
19:33:15 <imode> entering this place implies a lack of it.
19:33:17 <imode> ;)
19:39:54 <int-e> uh, I meant to write "I usually hide colors" there
19:40:09 <int-e> But the omission worked rather nicely.
19:41:41 -!- variable has joined.
19:42:03 <int-e> > let variable = variable in variable
19:42:07 <lambdabot>  *Exception: <<loop>>
19:45:11 -!- trout has quit (Ping timeout: 276 seconds).
19:55:14 -!- wob_jonas has joined.
19:56:17 <variable> int-e: hi
19:56:18 <wob_jonas> ais523: re numbers, yes, a very good example for that is Amycus, which is nominally defined to work on numbers, but actually works with binary trees, and an efficient implementation would have to use binary trees as the representation, becuase otherwise the numbers would grow too large
19:56:33 <wob_jonas> as in, not just exponentially large, but tetration large
19:58:20 <Taneb> Numbers are neat
19:59:00 <wob_jonas> and yes, the Turing-completeness proof of Consumer Society and the proof that it can also efficiently simulate a register machine (up to polylog slowdown) both use a two-stack machine
19:59:52 <wob_jonas> the two-stack machine can directly simulate a one-tape Turing machine, and you use the two stacks to store arbitrarily large numbers which you use as addresses to simulate a register tree manipulation machine
20:00:35 <wob_jonas> you're actually simulating a RAM machine with addresses, but I don't like RAM machines because there's too many different ways to define them and no one nice canonical one
20:01:28 <ais523> Thue is pretty similar to a Turing machine with insertion and deletion
20:01:31 <ais523> as is a two-stack machine
20:02:09 <wob_jonas> interestingly, there are at least two proofs though that I can use to simulate a two-stack machine, and both are interesting because either of them don't use the full power of Consumer Society, but it's two different things that they don't use
20:02:46 <ais523> Consumer Society doesn't seem to be on Esolang
20:02:54 <wob_jonas> but Consumer Society is not a tarpit, it's not easy to simulate
20:03:04 <wob_jonas> ais523: yes, it's a future language that I'll write up at some point
20:03:14 <wob_jonas> and I'm keeping its actual mechanics a secret until that
20:03:54 <imode> is it covered under ITAR?
20:04:08 <wob_jonas> what's an ITAR?
20:05:03 <imode> international traffic in arms regulations.
20:05:23 <imode> that joke about national secrets fell flat.
20:06:00 <wob_jonas> is that the thing why the license of some commercial software says that you can't sell them to Cuba or North Korea?
20:06:09 <imode> kinda yeah.
20:06:39 <Lymia> What is Consumer Society?
20:06:46 <Lymia> Not an esolang I can find on the wiki
20:06:56 <wob_jonas> Lymia: a future esolang that I will document eventually
20:07:07 <wob_jonas> I've had it in my head for like a year
20:07:32 <wob_jonas> I consider it very elegant, but YMMV
20:08:25 <wob_jonas> it's not like the tarpit languages of ais523 which try to be easy to simulate and hard to program, but it's like ais523's languages in that it has only very few operations because the programmer can just simulate everything else.
20:08:53 <ais523> mine vary in how hard they are to program in
20:09:02 <ais523> being hard to program in isn't an end goal, it's just a side effect
20:09:38 <Lymia> I have never actually designed an esolang for the sake of being an esolang
20:09:39 <Lymia> hmm
20:10:16 <ais523> what do you mean as "the sake of being an esolang"?
20:10:23 <wob_jonas> ais523: yes, exactly
20:10:50 <wob_jonas> Lymia: me neither. this just popped out as I examined non-eso languages and what operations they can do and noticed that a certain few operations are enough to do everything
20:11:10 <ais523> "increment target" and "dereference" :-P
20:11:50 <wob_jonas> or "increment counter" and "try to decrement counter if nonzero, conditional goto depending on whether it was zero"
20:11:58 <Lymia> S, K, and I?
20:12:09 <Lymia> ais523, I did a dumb thing for a Minecraft server plugin back in the day
20:12:14 <Lymia> it was an esolang because it had to fit on Minecraft signs
20:12:22 <wob_jonas> which are the two operations that Minsky or StackFlow have
20:12:53 <Lymia> If I was to do it again, I'd just implement Golfscript. :P
20:13:05 -!- trout has joined.
20:13:10 <ais523> wob_jonas: the typical counter machine has four operations (increment, decrement, zero test, goto), which can be minimized by grouping them in various ways
20:13:21 <ais523> Lymia: I doubt it, GolfScript is an "environment-execution-tied" language
20:13:38 <ais523> i.e. its semantics inherently rely on the language it's implemented in (IIRC Ruby?)
20:13:48 <ais523> and implementing it in anything else would require a Ruby interpreter
20:14:05 <ais523> I personally consider these languages very inelegant but it's common among golfing languages
20:14:10 <ais523> (and I have one of my own, A Pear Tree, which is tied to Perl)
20:14:22 <ais523> (but it doesn't try to hide it, like, e.g. GolfScript does)
20:14:37 <Lymia> . o O (JVM/CLR esolang that retains the esolang flavor)
20:15:02 <Lymia> <s>Oh wait, that's just Clojure</s>
20:15:16 <wob_jonas> ais523: yeah, I sort of prefer to assume the kind of counter machine that has no linear order of statements, but just states and one or two next state pointers in each state
20:15:19 <ais523> Lymia: just try to tarpit the JVM
20:15:33 <wob_jonas> and that's how I imagine the heap-allocating tree machine too
20:15:35 <ais523> it's close to an esolang in its own right, but it more resembles those BF derivatives that add far too many commands than anything else
20:15:45 <wob_jonas> Turing machines are usually defined that way too
20:15:55 <Lymia> JVM/CLR assembly themselves are... surprisingly reasonable.
20:16:09 <ais523> the odd thing is that you can't use its stack for TCness as you need to statically bound how high it is at every point in the program
20:16:16 <Lymia> There's 0 magic, unlike our friend SPIR-V
20:16:18 <ais523> please don't call JVM bytecode reasonable :-(
20:16:23 -!- variable has quit (Ping timeout: 276 seconds).
20:16:29 <ais523> I have worked with it for my day job, it's one of the more unreasonable ASMs I've seen
20:16:49 <ais523> why use a stack for most things, but registers for local variables and arguments, for example? (this is the exact opposite of how most asms do it)
20:17:37 <wob_jonas> ais523: hehe. whereas lua uses a stack for the local variables and function arguments, just like typical C to real processor compilers do
20:17:55 <ais523> why require that a pointer uses one stack slot and a 64-bit integer uses two? on any non-32-bit system, that's just going to require special cases to implement that behaviour specifically
20:18:17 <Lymia> (Because it was defined before 64-bit was a thing)
20:18:31 <Lymia> I think JVM actually still has 32-bit pointers on 64-bit too? Via some deep magic
20:19:32 <Lymia> ais523, what I should say is
20:19:37 <Lymia> It's not unreasonable or tarpitty to use.
20:19:49 <ais523> not tarpitty, sure
20:19:53 <ais523> I consider it to be unreasonable though
20:21:08 <Lymia> I suspect it's an encoding size concession, actually
20:21:25 <Lymia> The way Java/C# expressions work pretty easily translate into RPN, basically.
20:22:10 <Lymia> Since it's stack-based, there's no basically redundant location operands in every opcode.
20:22:23 <Lymia> In effect, it has local variables and expressions in RPN.
20:22:45 <ais523> the way modern Java toolchain work is to basically translate the Java into JVM as literally as they can
20:22:55 <ais523> and then decompile it and recompile it into something that's remotely optimised within the runtime
20:23:05 <wob_jonas> can you suggest interesting runs of games that aren't too well-known from either SGDQ 2018 or ESA Germany 2017? I don't have time to watch everything, but I'd like to see cool runs of games I don't yet know.
20:23:20 <ais523> I have a huge suspicion that the reason why Java JITs ended up becoming so good is that the AOT compilation is so bad
20:23:38 <wob_jonas> Don't bother with the weell-known games like Super Metroid or Super Mario 64 that is, I can already guess which of those I can watch.
20:23:40 <ais523> wob_jonas: I personally like Axiom Verge, the SGDQ run of it is perfectly adequate
20:24:11 <wob_jonas> Axiom Verge, ok, will look at that
20:24:22 <ais523> in general though you'll prefer the run more if you like the game / its genre
20:24:22 <Lymia> ais523, I wish Scala didn't take after javac's model of compilation
20:24:23 <Lymia> because
20:24:34 <Lymia> I'm not sure the JVM can really optimize some of the stuff it outputs.
20:24:48 <ais523> Lymia: I've lost track of just how bad javac's optimisation is
20:24:55 <ais523> it is comparable to gcc -O0, probably a bit worse
20:24:55 <wob_jonas> ais523: sure. I don't like fast-paced 3D games for example.
20:25:05 <wob_jonas> real 3D that is, where the player moves in 3D
20:25:13 <ais523> but you're OK if it's slower?
20:25:29 <wob_jonas> ais523: yes, in particular I like GTA Vice City runs because they're slower paced
20:25:58 <Lymia> There are the Pokemon RBY runs.
20:26:01 <Lymia> Which are.......
20:26:03 <Lymia> well
20:26:19 <wob_jonas> Lymia: I've already seen the two game one controller Pokemon blue and yellow
20:27:43 <Lymia> I remember there being a glitched 151 pokemon race?
20:28:00 <wob_jonas> Lymia: wasn't that last year? or winter?
20:28:07 <Lymia> idk
20:28:16 <Lymia> oh
20:28:17 <wob_jonas> no wait, that was the blindfolded glitched race
20:28:24 <Lymia> It wasn't this year, no
20:28:27 <wob_jonas> that one is amazing
20:28:41 <Lymia> ais523, a JVM/CLR tarpit would be interesting.
20:28:41 <wob_jonas> they did all the menu manipulation glitches blindfolded
20:28:55 <Lymia> It'd need to be still a tarpit while capable of...
20:29:10 <Lymia> At minimum: Defining classes with supertypes, implementing interfaces, overriding methods, doing basic OO operators
20:29:14 <ais523> I'm trying to figure out what properties of JVM bytecode even give it its TCness
20:29:31 <wob_jonas> this year was blue and yellow glitchless with the same controller
20:29:46 <ais523> I don't think it's possible to create two stacks without using objects to create linked lists, assuming integers have capped sizes
20:29:54 <ais523> (otherwise you can realloc arrays to get your storage)
20:30:20 <Lymia> I believe the JVM is only TC with the use of objects
20:30:27 <wob_jonas> ais523: isn't it the built-in classes like arrays that give it TC-ness the easiest way, just like in smalltalk on ruby?
20:30:40 <ais523> arrays aren't classes
20:30:52 <ais523> this sentence has caused several /months/ of additional work for one of my coworkers
20:31:03 <wob_jonas> arrays aren't a class?
20:31:07 <ais523> no
20:31:08 <Lymia> What do you work on, such that this is an issue for you?
20:31:09 <wob_jonas> I don't actually know JVM
20:31:10 <ais523> or, well
20:31:12 <ais523> array classes exist
20:31:18 <ais523> but arrays themselves don't act like objects of a standard class
20:31:45 <ais523> Lymia: well, part of my job is low-level JVM hacking
20:32:21 <wob_jonas> oh man, you don't want to know the ugly details I found out about VBA (Visual Basic Automation) recently. it's a very old language, but still used, and it's very ugly.
20:32:28 <Lymia> As in, like, what does your company do that necessitates that?
20:32:48 <ais523> wob_jonas: VBA is something like the third programming language I learned
20:32:52 <ais523> and it was my main language for years
20:32:52 <wob_jonas> they have a dictionary type in its standard library, but no easy way to sort a fucking array. the dictionary doesn't help because it's not a sorted one, it's an unordered one.
20:32:56 <ais523> at the time I didn't know better
20:33:11 -!- xa0 has quit (Excess Flood).
20:33:20 <wob_jonas> ais523: I'm luckier, I learned word basic, the original macro language from words 2 and word 6.
20:33:29 <ais523> Lymia: I'm a research programmer, my job's basically to implement ideas for new programming languages / techniques that other researchers come up with
20:33:36 <Lymia> .. ah.
20:33:45 <Lymia> And you've targeted the JVM before?
20:33:48 <Lymia> That makes sense.
20:33:56 <ais523> it's kind-of mindblowing that I effectively ended up with a job in esoprogramming
20:34:06 -!- xa0 has joined.
20:34:08 <Lymia> My first real programming language was Java.
20:34:20 <Lymia> I don't use Java anymore unless I need to
20:34:30 <ais523> in this case I'm working with existing Java code and attempting to transform it in ways that preserve its semantics
20:35:18 <wob_jonas> ais523: and I ended up with a job (that I think of as temporary) where I program VBA. it's not like I wanted to program VBA, but that's the programming interface a certain commercal program offers, so I have to use it at least in part.
20:35:25 <Lymia> Ooooh
20:35:43 <ais523> there are a lot of people working on this, though; I'm mostly working on the runtime
20:35:44 <Lymia> Idea for a JVM tarpit: The only thing the language can do are field accesses, and method calls.
20:35:50 <wob_jonas> I partly use it to export data to a file and then parse that file with a saner programming language, but this still involves a lot of digging around in VBA and its interface
20:36:04 <wob_jonas> Lymia: isn't that javascript?
20:36:17 <Lymia> Javascript still has math operators :P
20:36:18 <Lymia> And such
20:36:32 <wob_jonas> "math operations"
20:36:53 <wob_jonas> I'm a mathematician and I don't think javascript addition and subtraction are math operations
20:37:22 <wob_jonas> you know, like the php == operator, but even more weird
20:38:06 <Lymia> So.
20:38:24 <ais523> []+=`
20:38:28 <Lymia> Can you create a useful Java program with only if(), field accesses, and method calls? (Not even literals)
20:38:30 <wob_jonas> but yeah, it also has builtin while loops and such
20:38:36 <Lymia> That could be reduced into an esolang, I think
20:38:38 <ais523> Lymia: you don't need if
20:38:51 <ais523> Church booleans are the way to go here
20:38:59 <Lymia> oh right
20:39:18 <Lymia> If this language can define objects
20:39:30 <wob_jonas> ais523: so just embed lambda calculus in it, creating functions from strings with the same trick that jsfuck does?
20:39:40 <Lymia> It can make implicit branches via virtual methods.
20:39:44 <Lymia> So, no need for if.
20:39:50 <ais523> public class ChurchTrue implements ChurchBoolean { @Override public <T> if_(Supplier<T> ifFalse, Supplier<T> ifTrue) { return ifTrue.get(); }}
20:40:05 <wob_jonas> oh wait, you mean java
20:40:08 <wob_jonas> not javascript
20:40:10 <wob_jonas> sorry
20:40:16 <ais523> wob_jonas: you cannot use the same trick as JSFuck in Java
20:40:24 <wob_jonas> yeah
20:40:26 <ais523> although []+=` is the minimum known TC character subset of JavaScript
20:40:31 <wob_jonas> sorry, I just thought of javascript
20:40:50 <wob_jonas> Lymia: do you mean without method definitions?
20:40:51 <ais523> this mostly relies on how hideously overloaded + is
20:40:56 <wob_jonas> as in, you only call built-in methods?
20:40:58 <ais523> eventually we start using it to call functions
20:41:09 <ais523> wob_jonas: where would you put the calls?
20:41:11 <Lymia> hrm
20:41:21 <wob_jonas> ais523: a single main method, I'd say
20:41:33 <Lymia> I don't think this is doable without some access to method definitions.
20:41:38 <Lymia> But, maybe.
20:41:48 <ais523> in Java you can't even write any code without defining a method
20:42:00 <wob_jonas> but you'd use the built-in library and call standard methods from it
20:42:00 <Lymia> Also, we need a sufficiently esoteric syntax. :B
20:42:18 <Lymia> You need some way to get access to "machine" bools/ints
20:42:23 <Lymia> To call into the stdlib and do anything useful.
20:42:46 <ais523> I think "Church Java" might be more interesting
20:42:55 <ais523> but it's basically just typed lambda calculus with a ridiculously verbose syntax :-D
20:43:29 <Lymia> That sounds Java-like
20:43:40 <ais523> well, yes
20:43:41 -!- variable has joined.
20:43:43 <Lymia> "ridiculously verbose" is sure an description of that language
20:45:03 <ais523> modern Java isn't as bad as it used to be, but it's still quite bad
20:45:32 <ais523> instead of defining the ChurchTrue class you could just write «(f,t)->t.get()» whenever you wanted to use it
20:45:37 <ais523> as long as the type was clear from context
20:45:43 <Lymia> I do kinda want this to be "OOP taken ridiculously far" in how it feels.
20:45:52 <Lymia> But reducing it to actually FP concepts implemented using OOP functions is...
20:45:54 <Lymia> not that
20:46:17 <wob_jonas> isn't smalltalk already OOP taken ridiculously far?
20:46:25 <Lymia> Too much OOP, and you have 100 classes that each do nothing. This is a language where classes can't do anything but call other stuff.
20:47:01 -!- trout has quit (Ping timeout: 265 seconds).
20:47:27 <Lymia> A perverse enough language that BigInteger.ONE may be your best way of actually getting your hands on the ability to do math.
20:48:18 <ais523> you could probably wrangle up something out of the streams API
20:50:13 <Lymia> Syntatically, a method body can just be a list of method/function/etc names.
20:50:49 <Lymia> java.math.BigInteger.ONE; java.math.BigInteger.ONE; java.math.BigInteger.add(java.math.BigInteger);
20:51:51 <ais523> this language seems to have a severe lack of being able to store things long-term, due to the lack of a dup
20:52:07 <ais523> there's no way to produce more than one of a value
20:52:25 <ais523> which means that you can't, say, use an array to store things because once you read one of the elements, all the others will be lost
20:52:27 <Lymia> Right, since there's also no multiple return.
20:54:49 <Lymia> The simplest escape clause is the ability to reference method arguments multiple times, right?
20:55:52 <Lymia> It acts as a dup without there being an obviously "doesn't belong here" operation
20:56:38 <wob_jonas> Lymia: yes, but that's not enough
20:57:03 <Lymia> What would be missing?
20:57:57 <wob_jonas> I was thinking of a language that only has function definitions, where functions call other functions or conditionals, but no currying or function pointers, and it's not TC in itself, you need some way to store data, such as arrays or heap-allocated pairs or something
20:58:07 <wob_jonas> you'd only have a call stack, which isn't TC in itself
20:58:37 <wob_jonas> you can compile any program to a single-stack machine with limited depth
20:58:40 <wob_jonas> um
20:58:48 <wob_jonas> limited depth of how deep you can reach the stack that is
20:58:59 <wob_jonas> you know, just the ordinary one-stack machines
20:59:36 <Lymia> Isn't this enough to implement some subset of lambda calculus? (Assuming there's access to defining/implementing JVM interfaces)
20:59:45 <Lymia> Or, well.
20:59:48 <Lymia> All of it, basically
20:59:55 <wob_jonas> Lymia: no, because there are no function pointers or closures
21:00:15 <wob_jonas> of partially bound functions
21:00:19 <ais523> wob_jonas: apart from the "separate way to store data" you're thinking of https://esolangs.org/wiki/Splinter
21:00:29 <Lymia> Objects in Java can have virtual methods, and ctors effectively create closures.
21:00:36 <Lymia> (Assuming you can treat constructors as static methods)
21:02:46 <wob_jonas> Lymia: that might be enough
21:03:15 <ais523> Lymia: constructors are instance methods in the JVM, IIRC
21:03:26 <ais523> you construct an uninitialised object first then call the ctor on it
21:03:40 <Lymia> The language implementation can paper over this minor quibble :P
21:05:37 <wob_jonas> ais523: if you learned VBA, can you tell if I'm missing something stupid, or it really doesn't have any easy way to sort an array?
21:06:04 <ais523> I learned it when I was much younger and less understanding of programming style
21:06:11 <wob_jonas> I've seen actual sort implementations online on stack overflow or something
21:06:14 <ais523> I don't think I even /used/ arrays
21:06:28 <ais523> I mostly used it with Excel and placed values into the cells to do an array-like storage
21:06:28 <wob_jonas> which seems to suggest that there is no built in
21:06:42 <wob_jonas> I see
21:14:11 <Lymia> https://pastebin.com/bLLqghKq
21:14:18 <Lymia> A quick sketch of how this language could look
21:15:29 -!- trout has joined.
21:16:15 <zzo38> They are soon adding big integer arithmetic into JavaScript though, I think it is a good idea because then 64-bit integer arithmetic is possible (it is also helpful when you need unbounded integers, but they can also be used as 64-bit integers when that is what you need).
21:18:47 -!- variable has quit (Ping timeout: 276 seconds).
21:19:49 -!- tromp has quit (Remote host closed the connection).
21:32:05 -!- moei has quit (Quit: Leaving...).
21:38:43 -!- LKoen has quit (Quit: “It’s only logical. First you learn to talk, then you learn to think. Too bad it’s not the other way round.”).
21:45:53 -!- variable has joined.
21:49:47 <Taneb> What are some cool implications of the continuum hypothesis (or its negation)?
21:49:59 -!- trout has quit (Ping timeout: 276 seconds).
21:51:41 <zzo38> I don't know
21:57:01 -!- variable has quit (Quit: /dev/null is full).
21:58:14 -!- variable has joined.
21:58:33 -!- variable has quit (Client Quit).
21:59:19 -!- variable has joined.
21:59:20 -!- variable has quit (Client Quit).
21:59:51 -!- variable has joined.
22:00:06 -!- variable has quit (Client Quit).
22:04:10 -!- tromp has joined.
22:08:27 -!- tromp has quit (Ping timeout: 240 seconds).
22:09:08 -!- XorSwap has joined.
22:26:19 -!- imode has quit (Quit: WeeChat 2.1).
22:28:59 -!- AnotherTest has quit (Ping timeout: 276 seconds).
22:37:20 -!- tromp has joined.
22:41:27 -!- tromp has quit (Ping timeout: 240 seconds).
22:47:37 <Lymia> Surely this exists somewhere as an esolang.
22:48:04 <Lymia> A language with no explicitly defined text representation, and a well-defined IPA pronouncation 
23:13:07 -!- imode has joined.
23:19:50 -!- moei has joined.
23:30:36 -!- tromp has joined.
23:35:49 -!- tromp has quit (Ping timeout: 260 seconds).