00:00:50 <Train> I've finished my esolang at last.
00:02:36 <Train> Does anybody want to hear more? I also need to prove it's turing complete.
00:02:44 <Train> I'm almost certain that it is.
00:04:22 <zzo38> OK. What esolang is that?
00:05:05 <Train> It uses a 2d program with two pointers.
00:06:27 <Train> One pointer moves in cardinal directions if the other pointer is passing over a cardinal trigger.
00:07:01 <zzo38> OK. If you write the document, then we can read it.
00:07:27 <Train> Should i just post a couple of programs?
00:07:52 <zzo38> I think you should post documentation, although you can post programs too if you want to do.
00:08:07 <Train> Documentation is not finished yet.
00:08:15 <Train> I have an interpreter.
00:08:34 <Train> So, here is Hello, world!
00:08:45 <Train> WcWcWcWcWcWcWcWcWcWcWcWcWcO!dlrow ,olleH
00:09:14 <Train> Here is a CAT program:
00:09:20 <Train> note that it is 8 bytes
00:09:32 <Train> SdaaaaaaaaaaaaaaaanEcO
00:09:42 <Train> Sorry thats the truth machine
00:09:45 <zzo38> Eight bytes? How is that?
00:10:02 <Train> Top row is SdcN, bottom row is 4 spaces.
00:10:16 <Train> And here is the behemoth of all of my programs.
00:10:39 <Train> The ungolfed addition program, taking inputs that sum to any number less than or equal to 9
00:10:46 <Train> ---SdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaV
00:11:18 <Train> Well, it is golfed a little.
00:12:58 <Train> What do you think?
00:14:28 <zzo38> Well, I wouldn't know much yet, until I read the documentation, I think.
00:14:48 <Train> Alright. Time to make some documentation.
00:15:13 <Train> Hey, do you want to go to hackchat? It's easier to chat on than this.
00:15:43 <zzo38> I do not even know what is that, but I think this IRC is easily enough to chat on.
00:16:02 <Train> hackchat is a minimalist chat application.
00:17:45 <zzo38> I won't download any program, but if I can telnet to it, then I can try, I suppose. However, I think this IRC is better; it is where the discussions are for this and there is logs, which is also very useful, I think.
00:18:16 <Train> and hackchat supports full latex and code highlighting
00:18:24 <Train> I'll quickly set up a chatroom.
00:18:50 <Train> https://hack.chat/?esoteric
00:19:38 <zzo38> I don't want to use a web site for the chat. If it is a telnet then I can try
00:19:50 <Train> Why not a website?
00:20:29 <zzo38> For one thing, is not compatible with my computer, also WWW is rather hostile
00:20:43 <zzo38> (And, I am not sure that I believe you about "full latex highlighting")
00:20:50 <Train> Are you running some weird linux thing?
00:20:59 <Train> Or homebrew something
00:22:11 -!- j-bot has quit (Remote host closed the connection).
00:22:29 <zzo38> I am using Linux. Although, that isn't really relevant; IRC or telnet is better for interactive chat anyways, and the protocols are simpler you can use them without other software
00:23:17 <Train> So you don't have a browser.
00:23:25 -!- j-bot has joined.
00:23:28 <zzo38> I do, but not one compatible with hackchat
00:23:51 <zzo38> For playing GURPS on the computer, since I am the only player at this time, I just use a direct connection, together with ts and tee for logging. It is simple and works well.
00:24:32 <zzo38> (I would also avoid using the web browser as much as possible; it is the worst program on the computer. The other programs are better designed.)
00:25:44 <zzo38> (Although I didn't like the other IRC clients either, so I wrote my own; it isn't so difficult to write, really.)
00:28:39 <zzo38> Some people say IRC doesn't do that, NNTP doesn't do that, etc but that is not quite correct, because the protocol doesn't have to do those things; some things are independent from the protocol, and the user can use the client software they like, the server operator can set up and configure the server software they like.
00:29:15 <int-e> . o O ( Just make an electron app *runs* )
00:29:16 <zzo38> (I wrote my own NNTP client software too, actually. And my own NNTP server software.)
00:29:33 <int-e> (I'm really unhappy about Electron.)
00:30:38 <zzo38> I don't like Electron either. Although, if you document the protocol and then users can use whichever app they prefer, Electron or otherwise.
00:34:10 -!- j-bot has quit (Remote host closed the connection).
00:34:25 -!- j-bot has joined.
00:35:31 <Train> I am writing out the documentation.
00:44:12 -!- Train has quit (Remote host closed the connection).
00:52:24 <shachaf> int-e: I am boycotting electrons. Positive charge only for me.
00:53:43 <shachaf> Unfortunately I have two Electron programs on my computer, though one of them is usually not running.
00:54:21 <zzo38> Can you rewrite the program to not use Electron?
00:54:59 <int-e> Yes, you can rewrite programs.
00:55:02 <int-e> It's a lot of effort.
00:55:37 <shachaf> I can but it's a lot of effort.
00:55:51 <shachaf> One program is signal-desktop, which some people like to use to communicate.
00:56:12 <shachaf> I could reimplement the protocol and I'm sure I'd end up with something better because this program is very buggy.
00:56:34 <int-e> Hrm, why does that need the DOM part?
00:56:53 <int-e> (nodejs is perhaps only half as terrible as Electron)
00:57:07 <shachaf> It's a chat program with a user interface.
00:57:25 <shachaf> Oh, you mean, why can't I just use the existing implementation?
00:57:32 <int-e> Sorry, brain fart. I should've been able to recognize "signal".
00:57:49 <shachaf> I guess I could do that, though it would probably force me to use JavaScript and other nonsense.
00:58:22 <int-e> Nah,I thought about generic signals and didn't see why it needed a GUI.
00:58:43 <zzo38> Node.js isn't that bad; it is a way to write programs in JavaScript. But, there are other programming languages too; they shouldn't need JavaScript for everything, because there is many other one for different purposes; some others are better for the other purpose.
00:59:29 <zzo38> Also, you could use WebAssembly too if you want to; if you have a recently enough version of Node.js then you can also write in WebAssembly. But, you shouldn't need Node.js at all if you prefer to write in C instead, I think.
01:01:32 <int-e> . o O ( Customer: "I want to cook a pot of tea." Programmer: "Okay, let's start with this food factory over there..." )
01:02:27 <lambdabot> KOAK 260053Z 28013KT 10SM SCT200 BKN250 19/12 A3002 RMK AO2 SLP166 T01940117
01:03:08 <shachaf> I was outside today! What an experience, being outdoors. The weather was nice.
01:03:51 <zzo38> Yes, it is nice here too, and I was also outside today. But with this virus, I am not leaving the property where I live, although I will go in the back yard sometimes.
01:05:09 <shachaf> I do not have a back yard.
01:05:58 <orbitaldecay> Does anyone know what character is used on a traditional forth prompt?
01:06:02 -!- ArthurStrong has quit (Ping timeout: 260 seconds).
01:07:09 <imode> pop open gforth if you want an example.
01:07:35 <orbitaldecay> yeah, I was going to do that. Just wondering if anyone could answer it faster than it takes me to type apt install gforth && gforth
01:09:11 <zzo38> The traditional Forth prompt is "ok"
01:09:39 <int-e> ed has the best prompt
01:12:11 <int-e> how did this happen: bash: ed: command not found
01:12:45 <int-e> I guess I'm not editing files much these days ;)
01:15:50 <orbitaldecay> Looking for feedback on https://code.forder.cc/esolang/skiforth before I add it to the wiki.
01:18:40 <int-e> Without looking... just put it on the wiki? It can be edited and improved there after all...
01:31:30 -!- tromp has joined.
01:36:15 -!- tromp has quit (Ping timeout: 265 seconds).
01:38:41 -!- Train has joined.
01:39:04 <Train> With documentation.
01:40:55 -!- Train has quit (Remote host closed the connection).
01:57:03 <zzo38> I was able to get a screen shot from the .mcm file using the command: zcat | tail -c+33 | rgbff 160 144 But I still am not sure why it is the wrong screenshot. (Trying different offsets doesn't seem to help; I tried that)
01:58:29 <zzo38> I wrote that here so that we can remember its working.
02:26:32 <int-e> . o O ( /join ##zzo38-notes )
02:31:24 <zzo38> (Maybe you can tell what system the game is for by the command I used.)
02:49:46 <shachaf> int-e: Are you into Gröbner bases?
02:52:17 <HackEso> 1306) <shachaf> int-e: Do you like this? <int-e> It depends on the context. In the context of "Do you like _?", I hate it.
02:52:50 <shachaf> OK, but you seem like the sort of person who might be into them.
02:53:10 <shachaf> I guess I should have just looked at the logs before asking.
02:53:42 <int-e> I have a reasonable idea what they are, and none about the fine points (like choosing good monomial orders).
02:56:43 <int-e> I also shouldn't be awake right now.
02:57:22 <shachaf> OK, I read your explanation from 2014 and it makes sense.
03:19:34 -!- tromp has joined.
03:24:31 -!- tromp has quit (Ping timeout: 265 seconds).
03:43:18 <zzo38> Can you make Fermat's Last Theorem in Magic: the Gathering?
03:46:36 <zzo38> Also, if your opponent concedes a subgame, are you allowed to concede the subgame at the same time (to force the subgame to end in a draw)?
03:56:13 <esowiki> [[Truth-machine]] M https://esolangs.org/w/index.php?diff=71430&oldid=71339 * Cortex * (+66)
03:57:23 -!- Train has joined.
03:58:49 <Train> Here is the documentation:
03:58:58 <Train> Documentation for TrainCode
03:58:59 <Train> instruction pointer:
03:59:02 <Train> If it is any of ^V<>, change the direction of motion to the direction of the arrow.
03:59:04 <Train> direction of motion to right. Otherwise, set the direction of motion to down.
03:59:06 <Train> required direction.
04:00:55 <zzo38> Why don't you post it on esolang wiki instead? (I can interact with MediaWiki sites on my computer just fine, although you can't write on there if you do not have an account.)
04:01:14 <Train> I haven't made an account yet.
04:01:35 <Train> I'm asking you guys for feedback, and also because I need help proving the turing completeness.
04:01:38 <zzo38> You could also just post a text file, e.g. with sprunge, which is a simple paste bin
04:02:54 <zzo38> The advantage of sprunge is that you can use it either with a web browser or with curl, both to send and to receive, and no account is needed.
04:03:13 <Train> wait it supports curl
04:03:55 <Train> http://sprunge.us/7UDn3W
04:04:25 <Train> How on earth did I not know this?
04:08:41 <zzo38> OK, it look like good to me. It won't be Turing complete unless it has unlimited memory, either by an unlimited number of cells or being able to store numbers of an unlimited range in each cell.
04:08:56 <Train> I've worked that much out.
04:09:05 <zzo38> (Even if it does, that isn't the only criteria for Turing completeness though)
04:09:49 <Train> 't actually Turing complete at first, but I added "n" to make it Turing complete.
04:12:48 <Train> Also, do you know how I could golf my addition program?
04:14:11 <Train> here it is: http://sprunge.us/CIxpGR
04:14:11 -!- tromp has joined.
04:14:13 <zzo38> From your examples, it look like the instruction grid is the same as the data grid, so maybe it is possible to be Turing complete by self-modifying code without the "n" command, although I am unsure of such a thing. I have not proven it either way.
04:14:42 <Train> Yes, you are correct. However, I don't think that it is possible for it to be Turing complete without "n".
04:15:23 <zzo38> If cells store numbers in an unlimited range, then possibly you can try to prove Turing completeness by a Minsky machine.
04:15:28 <Train> Here's my reasoning: it has to carry out a different set of instructions based on input, and it can't conditionally branch without it, due to the fact that it doesn't have the mathematical manpower.
04:15:55 <Train> I might change it to unlimited range instead of 1 byte.
04:16:27 <zzo38> With a limited grid and limited range of values in each cell, it won't be Turing complete.
04:16:47 <Train> But in a theoretical infinite case, it is Turing complete.
04:16:53 <Train> Just like brainfuck isn
04:17:01 <Train> 't turing complete for a finite number of cells.
04:17:02 <zzo38> So you should change it to unlimited range, or else make the grid not wrap around (at least vertically, even if it does wrap around horizontally).
04:17:19 <Train> How would I go about I/O if I make it unlimited?
04:17:45 <zzo38> Input can still read a number in the range 0 to 255, and output can use the low 8-bits of the number.
04:18:03 <Train> Like the least significant 8 bits, or the most significant?
04:18:31 <zzo38> The least significant 8 bits.
04:18:39 -!- tromp has quit (Ping timeout: 265 seconds).
04:18:43 <Train> Okay, so basically VALUE MOD 256
04:19:01 <Train> Okie, modifiying the interpreter now.
04:19:21 <Train> It's great to talk to experts.
04:20:26 <Train> What about negative underflow?
04:21:51 <zzo38> Again, you can just use the low 8-bits, that is still defined for negative numbers, although the modulo operator in the programming language in use might not work with it; you can use "VALUE AND 255" if the programming language you use supports bitwise AND operator, then that would work.
04:22:27 <Train> So if I have -1, it wraps around to 255?
04:23:34 <zzo38> Yes, it is treated as 255 for purpose of output (although still store it as -1, if you want Turing completeness by unlimited range of values in cells).
04:24:36 <Train> Why does it need to be able to be negative for Turing completeness?
04:26:15 <zzo38> It doesn't, although it doesn't make sense for -1 to wrap around to 255 but for 256 to stay 256.
04:26:46 <Train> So, what should I do?
04:27:39 <zzo38> An alternative is to keep cell values bounded (in which case wrapping around from 0 to 255 and vice versa probably makes sense) and to instead make the grid size unbounded vertically (or horizontally), instead of wrapping; that would also make it Turing-complete.
04:28:02 <Train> I thought about that, but I just don't like the idea.
04:28:49 <esowiki> [[L]] https://esolangs.org/w/index.php?diff=71431&oldid=70824 * Voltage2007 * (-117)
04:31:13 <zzo38> What programming language is the implementation written in?
04:33:19 <zzo38> I don't know the capabilities of unlimited range numbers in Python, but hopefully you know what it is.
04:36:08 <Train> nvm figured it out.
04:42:39 <Train> So, how should I set up underflow?
04:42:53 <Train> Should I just say "it can't go under 0"
04:43:11 <zzo38> That is another possibility, yes.
04:43:29 <Train> It is tidy I guess.
04:43:48 <Train> But it's a bit cheaty.
04:44:21 <Train> I've got I/O and addition worked out now.
04:47:01 <Train> What is your expert opinion?
04:48:32 <zzo38> I am not really an expert, even though I know some things about it, I do not know everything.
04:49:04 <Train> You're pretty good at this ngl.
04:59:13 <Train> So, what do you think? You seem very experienced.
05:00:00 <zzo38> For one thing, I am not sure what exactly you are asking about. I did read the document you posted, and it look like OK to me, and these other stuff you now wrote also look like OK to me.
05:00:33 <zzo38> So if that is what you mean, then my answer is, I think it is good.
05:01:15 <Train> Okay, I'll rephrase. So, how should I set up negative numbers? Should I say "no, you can't have negative numbers" or should I just say "negative numbers allowed", or should i overflow it?
05:03:46 <zzo38> I think the mathematically sensible thing to do is to allow them, and use the low 8-bits for output, just like with positive numbers (it is well-defined how to do this).
05:04:07 <Train> Okay, so just reuse modulo again.
05:05:20 <zzo38> Yes, although in many programming languages, the result of modulo has the sign of the left operand, rather than the right, but if you have bitwise operators, use AND 255 instead of MOD 256 and then you avoid that problem (and the result is the same for positive numbers).
05:14:08 <Train> What on earth do you mean? I get the bit about the sign of the left operand rather than the right, but what do you mean by a bitwise operator?
05:15:02 <Train> Okay, I think I know what you mean.
05:15:10 <Train> I'll test it in Python now.
05:15:38 <Train> Okay, it works fine.
05:15:57 <Train> % is python's modulo operator, and -1%256 is 255
05:16:11 <Train> Uploaded to compiler.
05:18:55 <zzo38> OK, then in Python the modulo operator does use the right sign, unlike C and dc, so it works.
05:24:46 <zzo38> This can be tested: If you write "d" and then "a" 256 times (or "b" 256 times) and then "c" and then "n", it should output the same byte as the input but always go down instead of right, even if you input a space. Then it will use unbounded cell values correctly in that case.
05:25:32 <Train> alright, testing it now
05:27:52 <Train> The interpreter is free of bugs.
05:28:17 <Train> I also found a pseudo-quine:
05:28:37 <zzo38> Ah, yes, that will work.
05:28:58 <zzo38> (Although it won't terminate)
05:29:30 <Train> Are there any quines that terminate? (Other than the trivial case of the null program)
05:31:20 <zzo38> I will try to think of it.
05:31:58 <Train> I haven't been able to find any terminating quines, but I know that there are several different classes of non-terminating types.
05:32:09 <Train> Each class has an infinity of solutions.
05:36:11 <Train> Also, did you find a way to golf the addition program? 357 bytes is a lot!
05:40:40 <zzo38> No, although right now I will think of the quine, and then perhaps tomorrow I might look at the addition program again
05:53:11 -!- Train has quit (Remote host closed the connection).
05:55:17 -!- Lymia has quit (Remote host closed the connection).
05:55:32 -!- Lymia has joined.
06:02:06 -!- tromp has joined.
06:06:55 -!- tromp has quit (Ping timeout: 265 seconds).
06:56:22 -!- tromp has joined.
07:01:29 -!- tromp has quit (Ping timeout: 272 seconds).
07:14:52 -!- tromp has joined.
07:19:54 -!- tromp has quit (Ping timeout: 265 seconds).
07:24:12 -!- tromp has joined.
07:25:50 -!- imode has quit (Ping timeout: 260 seconds).
07:32:44 <zzo38> I think now I figured out how to make a quine with TrainCode.
07:33:03 <zzo38> (My program is ten bytes long)
08:04:59 <esowiki> [[L]] M https://esolangs.org/w/index.php?diff=71432&oldid=71431 * Hakerh400 * (+8) Two adjacent single quote characters must be escaped in order to be visible in the rendered HTML of the page
08:06:20 <esowiki> [[L]] M https://esolangs.org/w/index.php?diff=71433&oldid=71432 * Hakerh400 * (+8) ditto
08:30:27 -!- LKoen has joined.
08:58:18 -!- ArthurStrong has joined.
09:14:30 <esowiki> [[Stopwatch]] M https://esolangs.org/w/index.php?diff=71434&oldid=70876 * GDavid * (+3) Step -> split
09:16:22 <esowiki> [[Talk:Stopwatch]] https://esolangs.org/w/index.php?diff=71435&oldid=71406 * GDavid * (+134)
09:21:36 -!- LKoen has quit (Remote host closed the connection).
09:22:53 -!- LKoen has joined.
10:45:51 -!- rain1 has joined.
11:07:07 -!- kspalaiologos has joined.
11:21:54 -!- Lord_of_Life_ has joined.
11:24:45 -!- Lord_of_Life has quit (Ping timeout: 240 seconds).
11:24:51 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
12:57:17 -!- rawr has quit (Quit: They're putting dbus in the kernel. For fairness, I want a Java RMI registry in the linux kernel too. dont @ me).
13:00:55 -!- rawr has joined.
13:41:38 -!- arseniiv has joined.
13:54:31 -!- Phantom_Hoover has joined.
14:08:09 -!- sprocklem has quit (Ping timeout: 265 seconds).
14:09:27 -!- sprocklem has joined.
14:26:05 <fungot> kspalaiologos: mind is fuzzed right now here we have both
14:26:28 <esowiki> [[Skiforth]] N https://esolangs.org/w/index.php?oldid=71436 * Orby * (+1844) Creating Skiforth page
14:28:23 <esowiki> [[User:Orby]] https://esolangs.org/w/index.php?diff=71437&oldid=71319 * Orby * (+49)
14:30:02 <esowiki> [[Skiforth]] M https://esolangs.org/w/index.php?diff=71438&oldid=71436 * Orby * (-1) /* Examples */ Fixing small typo
14:48:34 <arseniiv> is there an interesting way to do diffusion-limited aggregation in The Powder Toy? I know a simple one: spam fog when ambient heat is off, then place a nucleus somewhere or just wait. But that makes pretty boring images
14:49:06 <arseniiv> uh I probably should join #powder or something :D
15:09:59 <tromp> ine-e: would you like to add a variation of BB_lambda to OEIS?
15:10:30 -!- Melvar` has joined.
15:14:22 -!- Melvar has quit (Ping timeout: 265 seconds).
15:25:15 -!- Phantom_Hoover has quit (Ping timeout: 240 seconds).
15:33:44 <int-e> tromp: surprisingly, that did not highlight me ;)
15:34:52 <int-e> tromp: Somewhat tempting, but I haven't found motivation for basically anything this week. So for now, no.
15:35:28 <int-e> (even though I do have an OEIS account)
15:35:34 <tromp> would be a good way dto showcase your KO complexity
15:36:08 <int-e> Sure, but it can wait.
15:37:38 <tromp> PS: i completed the 36 TODOs in BB.txt
15:38:15 <tromp> still waiting for latest draft to be published
15:48:27 -!- Cale has quit (Ping timeout: 252 seconds).
15:58:23 -!- imode has joined.
16:01:48 -!- Cale has joined.
16:05:36 -!- Phantom_Hoover has joined.
16:11:43 <zzo38> That is the quine for the TrainCode that I figured out earlier
16:12:10 <zzo38> (Although I have not actually tried to execute this program on the computer, so it is untested)
16:18:35 <esowiki> [[Post Dominos]] M https://esolangs.org/w/index.php?diff=71439&oldid=65386 * Orby * (+4) FIxing broken link
16:23:33 <esowiki> [[Semordnilap]] M https://esolangs.org/w/index.php?diff=71440&oldid=65381 * Orby * (+4) Fixing more broken links
16:30:47 <zzo38> (The comma and P have no meaning.)
16:59:02 <imode> inetd/xinetd seems to have been forgotten by a lot of mainstream developers. putting your crap in the cloud should be as simple as throwing a binary up there along with a service interlayer that hooks the sockets up for you.
16:59:36 <imode> we're back to CGI with Lambda, why not general TCP/UDP serves.
17:02:55 <zzo38> Although, that is mainly because I implemented my own NNTP server and Gopher server and QOTD server.
17:03:24 <imode> right. if you wanted to handle web requests, use CGI.
17:04:16 <zzo38> Yes, CGI is useful for handing web requests, and xinetd is useful for handling such things as NNTP and so on.
17:04:59 <imode> I currently work for Amazon and I'm kind of shocked at the kinds of architecture people are promoting internally. it is _literally_ like CGI apps of the early 2000's.
17:05:09 <imode> just using "modern infrastructure".
17:09:12 <zzo38> Do you like this quine program?
17:29:20 <int-e> imode: so... simplicity by spawning a new process on every request?
17:30:03 <int-e> imode: If so, will they reinvent fastcgi next to save the fork/exec overhead? :)
17:30:11 <int-e> Or maybe preforking, preforking is cool too.
17:30:13 <imode> hahahaha, pretty much already have.
17:30:26 <imode> it's kind of disturbing. everything old is new again, but with accounting hooks attached.
17:30:43 <int-e> What do they call it though...
17:31:00 <int-e> hmm. single shot server
17:31:09 <int-e> something like that, maybe a bit cooler.
17:31:46 <imode> lambda is essentially fastcgi in that it can pass stuff between requests.
17:34:24 <imode> eventually I expect someone to recommend me the bchs stack but un-un-unironically.
17:34:34 <int-e> . o O ( Achievement of the day: I made the prompt of my Raspberry logins raspberry-colored. )
17:56:15 -!- Phantom_Hoover has quit (Ping timeout: 240 seconds).
18:23:25 -!- kspalaiologos has quit (Quit: Leaving).
18:34:42 -!- xkapastel has joined.
18:38:16 -!- Phantom_Hoover has joined.
18:50:46 -!- arseniiv_ has joined.
18:52:58 -!- arseniiv has quit (Ping timeout: 246 seconds).
18:57:30 -!- rain1 has quit (Quit: leaving).
19:10:03 <myname> i started writing a terminal ide for funciton. i am planing on a debugger, too. any non-obvious feature suggestions?
19:19:54 <arseniiv_> myname: I get it copy-pasting is obvious? Maybe some input/output/wire rearrangements?
19:19:59 -!- arseniiv_ has changed nick to arseniiv.
19:20:24 <myname> actually, i didn't consider copy-pasting yet :D
19:20:48 <myname> what do you mean by rearrangement?
19:20:55 <myname> https://imgur.com/a/7rZNuzF
19:24:18 <arseniiv> <myname> what do you mean by rearrangement? => a basic feature here would be simply moving (groups of) blocks to anywhere user wishes, with automatical rerouting of wires. I think there can be more to it, too, but I need to re-read Funciton page
19:25:07 <myname> arseniiv: i did consider that. like, removing wires where you are moving a block to and automatically extending at the other end
19:25:24 <myname> i am not sure how to feel about crossing wires yet, though
19:26:06 <arseniiv> hm, also how about find/replace? Allow replacing a, say, single block with a several blocks, if inputs and outputs are somehow made into correspondence
19:26:40 <myname> that would be tough ui-wise
19:28:32 <arseniiv> though hm I think the natural thing would be to move in the opposite direction: refactoring out functions from block groups. That would still require mapping inputs/outputs but maybe this case would be somehow easier
19:31:04 <arseniiv> myname: or how about inputting not just single blocks, but also frequently used block groups? Though are there any quickly identifiable ones…
19:31:41 <arseniiv> now my imagination is quite bounded, my suggestions are all variations on the same theme I think :D
19:37:09 <arseniiv> now I remember the nop function is needed to make crossings
19:43:52 -!- imode has quit (Ping timeout: 244 seconds).
19:45:49 -!- Melvar` has quit (Ping timeout: 246 seconds).
19:46:30 <arseniiv> https://esolangs.org/wiki/Funciton/Brainfuckiton ← I like a little ladder in there (in the giant BF◊ function)
19:48:08 <arseniiv> myname: oh! maybe there could be a simple compactification feature utilizing these ladders
19:49:10 <arseniiv> if no secret, what language are you going to use?
19:50:01 <myname> i am using js, because i really like blessed-js
19:54:39 <myname> the fluffiest tui library i have ever seen
19:58:36 <arseniiv> huh, I didn’t expect that from js
19:59:14 -!- Melvar` has joined.
19:59:28 <myname> but if you are into tuis, give it a shot
20:03:54 <myname> https://github.com/embarklabs/neo-blessed
20:21:45 <zzo38> I have used blessed too (although not much)
20:22:06 <myname> what did you do with it
20:34:46 <zzo38> I tried to make a configuration TUI for mahjong rules, although since then I made up an entirely different thing which uses a plain text file and is far more flexible with the rules it is possible to define.
20:41:16 <zzo38> (I might also have other uses for blessed in future, although not right now; I am unsure.)
20:54:23 -!- xkapastel has quit (Quit: Connection closed for inactivity).
21:00:22 -!- arseniiv has quit (Ping timeout: 246 seconds).
21:30:08 -!- 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:40:07 -!- tromp has quit (Remote host closed the connection).
21:40:30 -!- ArthurStrong has quit (Quit: leaving).
21:41:24 -!- tromp has joined.
22:00:34 -!- Train has joined.
22:04:13 <zzo38> Train: Hello, I figured out the quine. It is: c,E,c,a,EP
22:04:52 <zzo38> Yes, P at the end.
22:05:09 <Train> why P? is it because of its value?
22:05:22 <zzo38> Yes; it is one more than O.
22:06:17 <Train> cEccaEFFGGHHIIJJKKLLMMNNO
22:07:18 <zzo38> O, it doesn't works.
22:07:42 <Train> i'll give you the instruction log
22:08:24 <zzo38> (Possibly something I did not understand about it, or possibly just I made a mistake)
22:08:51 <Train> EcaEPcDcaEPcDbbEPcDbcFPcDbcGPcDbcHPcDbcIPcDbcJPcDbcKPcDbcLPcDbcMPcDbcNPcDbcO
22:08:57 <Train> That's the debug log.
22:11:31 <Train> I don't think there are any single-line quines.
22:13:02 -!- Phantom_Hoover has quit (Ping timeout: 260 seconds).
22:18:35 <zzo38> I do not understand the debug log. What does it mean?
22:19:01 <Train> It's a list of the commands that the program cycled through.
22:19:38 <zzo38> Why doesn't it include the initial "c" and the commas?
22:20:14 -!- imode has joined.
22:20:30 <Train> Oh i didn't realise it needed commas
22:20:35 <Train> c,E,c,a,EP outputs c,E,c,a,EP
22:20:40 <Train> can you explain how you got it?
22:20:44 <zzo38> O, so it does work.
22:20:54 <Train> How did you obtain the quine?
22:22:20 <zzo38> Well, I thought of a few different ideas, and then I thought it would have to avoid modifying some commands, so I put interleaved commands that are meaningless. But, finally it will have to terminate, so at the end I put P instead of a comma, so that it changes to O and then it will stop.
22:22:50 <Train> Thats really smart.
22:22:58 <Train> And you say you don't have much experience in this?
22:23:41 <zzo38> Well, I have more experience in this than people who do not have experience in this.
22:23:55 <zzo38> But these kind of things isn't everything I do in my life.
22:24:10 <Train> I have quite a bit of experience, but this is my first fully finished esolang which is a proper turing tarpit.
22:29:10 <Train> I'm trying to make a brainfuck interpreter in it right now.
22:29:22 <Train> That will properly prove it's turing complete.
22:30:37 <Train> Do you think that is easily possible?
22:31:00 <zzo38> Yes, that will, although a way to convert a Minsky machine to TrainCode would also prove it Turing complete.
22:31:57 <zzo38> (And that also seems easier to me, although I don't actually know because I haven't actually tried, so I just guess.)
22:32:10 <Train> I don't really understand what a Minsky machine is.
22:32:35 <Train> I understand the whole "there are x unbounded registers with two operations"
22:32:47 <Train> but i don't understand the alternate state transition
22:33:55 <zzo38> Well, if one register is zero, then it won't decrement and instead will make an alternate state transition. In TrainCode, you would use 32 instead of 0, and you would write "na" (with the "a" to the right of the "n") to produce the failing decrement, and do something else instead in that case.
22:34:42 <Train> does it have to be anything specific, or can it just be literally anything
22:35:11 <zzo38> I do not understand your question.
22:35:28 <Train> in the case of the failing decrement, what do I do?
22:36:08 <zzo38> A successful or failed decrement will jump to a different part of the code, causing different code to be executed. (This is what your "n" command does.)
22:44:43 <Train> I'll use 2 registers. Does that make it Turing complete?
22:46:12 <zzo38> Two registers is sufficient for Turing completeness.
22:46:29 <Train> Sweet. I'll use the cells at 0,1 and 1,1 for the registers.
22:47:00 <Train> I'll also need some way to store the code, or I could just directly output it.
22:47:49 <zzo38> I suggested using an external program which is capable of converting any Minsky machine (of two registers) into TrainCode; if it can do that, that is sufficient to prove Turing completeness.
22:48:39 <Train> Okay... couldn't I just have an I/O for the code.
22:49:02 <zzo38> (The converter can be written in whatever programming language you want)
22:49:32 <zzo38> You could just have an I/O for the code, although it is probably easier to convert it with a separate program.
22:50:11 <Train> Because stacked "n" commands allow for really easy elifs, I reckon I could do that.
22:51:31 <zzo38> Yes, it does do that.
22:51:47 <Train> So what are the operations?
22:51:54 <Train> I think I need four operations...?
22:52:11 <Train> Add to R1, subtract to R1 and the same for R2
22:52:34 <zzo38> Yes, and flow control based on whether the decrement is successful or failed.
22:52:40 <Train> And if the subtraction operation fails, it jumps forward a certain amount?
22:52:47 <Train> Is that what you mean?
22:53:18 <zzo38> The program tells it where to jump to.
22:55:04 <Train> How does the program tell it where to jump to?
22:55:18 <zzo38> I am not sure how else to explain right now
22:55:57 <Train> Can you explain it really simply, step by step, because I am reasonably new to esolanging.
22:57:56 <zzo38> Well, an alternative is The Amnesiac From Minsk; level 1 and 2 are Turing complete.
22:59:19 <zzo38> (Although I think Amnesiac From Minsk requires more than two registers to be Turing complete)
23:00:51 <Train> So, what does a failed decrement do?
23:00:58 <Train> Say we have both registers at 1
23:01:19 <Train> and we add one to the second one and decrement the second one twice.
23:01:23 <Train> what does that do?
23:01:36 <zzo38> Like a GOTO command, each decrement command in the program specifies what part of the program to execute next.
23:02:08 <Train> So, how does a decrement say where to GOTO?
23:02:58 <zzo38> By specifying the address of the next instruction.
23:03:15 <Train> Okay... but it is just a decrement.
23:06:42 <Train> how does it specify an address?
23:07:12 <zzo38> Well, it is a parameter for the command.
23:07:12 <Train> The esolang wiki isn't very helpful either, and neither is wikipedia.
23:09:38 <Train> so the decrement command actually takes a parameter
23:09:59 <Train> so it's not just a decrement by 1
23:10:52 <zzo38> It is just a decrement by 1; the parameter is where to jump to.
23:11:23 <Train> Okay, so a decrement command takes 1 parameter, and if that decrement command cannot be executed, it jumps to that address in the program memory.
23:12:56 <Train> Is there a limit on how small the program can be to ensure turing completeness, or does it tend towards infinity?
23:13:26 <Train> In theory, TrainCode should be able to implement a minsky machine..
23:14:43 <Train> Because it has flow control with "n"
23:20:08 <Train> First, I'll implement a Minsky engine which I can then use a python program to produce traincode that can be fed into the Minsky Engine.
23:21:14 <Train> This will be hard.
23:21:34 <Train> Just going to brainstorm on here, check me if I'm wrong.
23:22:05 -!- orbitaldecay has changed nick to orby.
23:22:10 <Train> So, Line 2 of the code will be the Minsky instructions.
23:22:11 -!- orby has changed nick to orbitaldecay.
23:23:30 <int-e> mmm where is TrainCode?
23:24:28 <Train> But here's traincode: http://sprunge.us/7UDn3W
23:25:50 -!- Lord_of_Life has quit (Ping timeout: 260 seconds).
23:26:12 -!- Lord_of_Life has joined.
23:27:07 <Train> zzo38, I think TrainCode does already have an infinite memory because of the size of the program.
23:27:20 <Train> Additionally, I need a better name for it.
23:27:29 <Train> TrainCode is not a very good name.
23:27:44 <int-e> look at this beautiful prompt color https://int-e.eu/~bf3/tmp/fruit.png :P
23:28:16 <Train> The font hurts, but it is a nice colour.
23:28:39 <int-e> it's a perfect raspberry color
23:28:51 <int-e> The font... well I've been using that same font for more than 20 years.
23:29:02 <int-e> It's hard to change now.
23:29:06 <zzo38> Why is the font hurts? It is the same font I use on my computer (but with different colours)
23:29:13 <Train> I prefer gridded fonts personally.
23:29:21 <int-e> (obviously it's not scaled up like that)
23:29:24 <Train> Or MC enchantment table.
23:29:29 <zzo38> And I prefer it than the other font
23:29:39 <Train> Anyway, back to esolanging.
23:30:07 <int-e> Train: basically as long as my eyes can take it I'll probably stick to this font... I know its quirks (e.g. how 0 and O or l and | look...)
23:30:09 <zzo38> I don't know what is the better name for it.
23:30:23 <int-e> Train: But that doesn't mean anybody else should feel good about it :)
23:30:25 <Train> I'm thinking maybe something latin might sound nice.
23:31:26 <Train> Veritas sounds nice.
23:31:30 <Train> It's latin for Truth.
23:31:46 <zzo38> But, the size of the program doesn't cause it to have infinite memory; it only allows the programmer to set the memory to an arbitrarily large finite size, which isn't quite the same thing. Allowing the values of cells to be of unlimited range does give it infinite memory though.
23:32:10 <Train> But in the special case of the minsky machine, there is no difference.
23:35:58 <int-e> Train: I just saw \ and /. And I'm reminded of https://esolangs.org/wiki/Trajedy even though that's very different.
23:36:58 <Train> Huh. I'd never even heard of Trajedy.
23:37:39 <int-e> I imagine that's probably true of most of the languages on the wiki :)
23:37:50 <Train> Lol, there's like 5000.
23:38:27 <int-e> Trajedy actually sparked quite a bit of discussion here when it was new (involving myself as well) though so it stood out.
23:38:43 <Train> It's an interesting concept.
23:39:08 <Train> I'm surprised it's turing complete.
23:39:43 <Train> But I can see how it is.
23:40:13 <Train> Anyway, I call dibs on language name Veritas, and because this chat is logged, people can see this.
23:43:07 * int-e wonders how terrible Traincode would become without the n.
23:44:04 <Train> n is the only thing that can make flow control
23:44:14 <int-e> (you'd have to do *everything* with self-modifying code)
23:44:34 <int-e> whioch isn't unheard of in esolangs
23:44:35 <Train> but I've already established that's impossible to do *everything*
23:45:09 <Train> most problems are possible, but none are trivial without n, and there are some that are impossible
23:45:11 <int-e> well, the wraparound kills the idea of infinite state, unless you start with an infinite grid
23:45:25 <Train> infinite number of states in each cell
23:45:26 <int-e> which, conceptually, I believe you could do
23:45:39 <Train> I could easily make an infinite grid.
23:45:45 <Train> But I chose a finite grid.
23:46:32 <int-e> The thing is, you could do that without radically changing the nature of the language. People have done similar things with Brainfuck.
23:46:54 <Train> Yeah, I made a brainfuck interpreter that had that.
23:47:20 <int-e> (The original Brainfuck had 30k byte-sized cells... few clones adhered to that)
23:48:43 <Train> In my interpreter I kept the byte-sized cells, but made it infinite.
23:48:55 <Train> Was the original brainfuck turing-complete?
23:49:27 <int-e> Anyway, Traincode is a kind of minimal Befunge which judging by https://esolangs.org/wiki/Befunge#Related_languages is a surprisingly small niche.
23:49:41 <int-e> No, the original Brainfuck suffered from the limitation of having finite state.
23:50:10 <Train> So a turing-complete system must have infinite states?
23:50:31 <int-e> Yes. TC-ness is a bit overrated.
23:51:16 <Train> Yes, especially because esolangs are ESOTERIC
23:51:33 <Train> Almost any system is turing-complete.
23:51:44 <Train> Without too much effort.
23:51:50 <int-e> The usual view on any computer is that it's a finite state machine with a ridiculously huge state space... easily 2^2^2^40 states *excluding* external storage.
23:52:16 <int-e> So there's a disconnect between TC-ness (which computers aren't) and being useful for programming (which computers very much are).
23:52:20 <Train> Yep, but most esolangs deal with the hypothetical infinite case for the turing completeness proof.
23:52:35 <int-e> An interesting esolang case is Malbolge.
23:53:08 <Train> Remember that paper which showed a way to functionally program in Malbolge?
23:53:48 <int-e> which has about 3^590490 states, which technically makes it a finite state machine, but you can still program it by selecting starting states that exhibit interesting behavior.
23:54:29 <int-e> No, I don't. I have not actually delved into Malbolge programming... still amazed that people actually accomplished it :)
23:54:32 <Train> Since it has a finite number of programs, is it Turing complete? I wouldn't think so...
23:55:17 <int-e> But it did change my view on what constitutes programming, and how it relates (or doesn't) to Turing-completeness.
23:55:34 <Train> Yes. Malbolge is one of the more out-there ones.
23:55:37 <int-e> It's a finite state machine, so it's not TC.
23:56:38 <int-e> There's Malbolge Unshackled which lifts the memory constraint and is TC (as a programming language; implementations will be constrained by computer hardware).
23:57:07 <Train> It's just one of those languages that makes you think "who was sadistic enough to think of this"
23:58:22 <Train> Here's the Malbolge truth machine:
23:58:24 <Train> (aONMLKJIHGFEDCBA@?>=<;:98765FD21dd!-,O*)y'&v5#"!DC|Qzf,*vutsrqpF!Clk|ih