←2020-06-18 2020-06-19 2020-06-20→ ↑2020 ↑all
00:50:10 -!- sebbu2 has joined.
00:51:08 -!- sebbu has quit (Ping timeout: 256 seconds).
01:01:24 <esowiki> [[International Phonetic Esoteric Language]] https://esolangs.org/w/index.php?diff=73974&oldid=73811 * Bigyihsuan * (+274) /* IO */
01:02:35 <esowiki> [[International Phonetic Esoteric Language]] https://esolangs.org/w/index.php?diff=73975&oldid=73974 * Bigyihsuan * (+85) /* Plosives: Stack Operations */
01:02:51 <esowiki> [[International Phonetic Esoteric Language]] https://esolangs.org/w/index.php?diff=73976&oldid=73975 * Bigyihsuan * (+0) /* IO */
01:09:33 <esowiki> [[GORBITSA]] https://esolangs.org/w/index.php?diff=73977&oldid=73969 * ZippyMagician * (+1066) Self-interpreter
01:12:55 <esowiki> [[GORBITSA]] https://esolangs.org/w/index.php?diff=73978&oldid=73977 * ZippyMagician * (+40) Clarification (self-interpreter)
01:16:05 <esowiki> [[International Phonetic Esoteric Language]] https://esolangs.org/w/index.php?diff=73979&oldid=73976 * Bigyihsuan * (+830) /* Overview */
01:19:58 <esowiki> [[GORBITSA]] https://esolangs.org/w/index.php?diff=73980&oldid=73978 * ZippyMagician * (-34) Marked as implemented
01:20:08 <esowiki> [[International Phonetic Esoteric Language]] https://esolangs.org/w/index.php?diff=73981&oldid=73979 * Bigyihsuan * (+303) /* The Register */
02:01:37 <zzo38> Sometimes, in order to win the game, you must concede.
02:02:38 <shachaf> Which game? Magic: The Gathering?
02:03:31 <zzo38> Yes, although maybe other games too I don't know.
02:05:22 <shachaf> How can you win that game by conceding?
02:06:18 -!- Phantom__Hoover has joined.
02:07:07 <zzo38> Well, sometimes it is possible in case of team games or subgames.
02:11:32 <zzo38> For example, see: http://zzo38computer.org/textfile/miscellaneous/magic_card/puzzle.5
02:36:14 <zzo38> Apparently, Wizards of the Coast seems to really hate Time Spiral block. But I think is better than most blocks, and some other people also think. At least, this is what some people wrote on the comments.
02:51:19 -!- Soni has quit (Quit: http://quassel-irc.org - Chat comfortably. Anywhere.).
02:55:15 -!- imode has joined.
03:09:54 -!- Phantom__Hoover has quit (Ping timeout: 240 seconds).
03:28:47 -!- ArthurSt1ong has quit (Quit: leaving).
03:29:08 -!- ArthurStrong has joined.
04:11:45 <ArthurStrong> Hi all. Dear lazyweb, what are practical uses of regex backresolves? Wondering...
05:27:46 -!- Soni has joined.
05:27:55 -!- ais523 has joined.
05:28:21 <ais523> ArthurStrong: do you mean "backreferences"? not sure about /practical/, but some people have used them for some unexpectedly powerful esoprograms
05:28:24 -!- adu has quit (Quit: adu).
05:31:04 <ais523> for example, here's a regex (not made by me!) that divides a number (expressed in bijective unary) by sqrt(2): https://codegolf.stackexchange.com/questions/198427/shift-right-by-half-a-bit/198428#198428
05:33:11 <ais523> similarly, here's a regex (made by the same person as the above regex) that matches factorials (expressed in bijective unary): https://codegolf.stackexchange.com/questions/121731/is-this-number-a-factorial/178979#178979
05:39:53 <ais523> on a related note, are all linear bound automata primitive recursive?
06:13:09 -!- Cale has quit (Ping timeout: 265 seconds).
06:15:25 -!- tromp has joined.
06:20:00 -!- Cale has joined.
06:25:30 <zzo38> They said JavaScript doesn't have a integer type; well, it does now, and I think it did even when that message was written
06:25:51 <zzo38> (However, its integer type is signed, not unsigned.)
07:28:42 <shachaf> `5 w
07:28:46 <HackEso> 1/1:gray//Gray is e common misspalling of grey. \ currying//Functions are curried by taking curry(f). \ topology//Topology is another name for topos theory. \ ssr//SSR is Steven's Sausage Roll. \ itay//Itay is Christmas in Italy.
07:33:57 -!- rain1 has joined.
07:49:34 -!- LKoen has joined.
07:55:23 -!- cpressey has joined.
08:13:46 -!- imode has quit (Ping timeout: 256 seconds).
08:31:06 -!- Phantom__Hoover has joined.
08:45:45 <esowiki> [[Tandem]] N https://esolangs.org/w/index.php?oldid=73982 * Chris Pressey * (+14554) Created page with "'''Tandem''' is an experimental rewriting language, designed by [[Chris Pressey]] in June 2020, where the rewrite rules form a Kleene algebra. The object being rewritten by a..."
08:48:16 <esowiki> [[Tandem]] M https://esolangs.org/w/index.php?diff=73983&oldid=73982 * Chris Pressey * (-3) /* Implementing Automata in Tandem */ grammar
08:53:14 <esowiki> [[Tandem]] https://esolangs.org/w/index.php?diff=73984&oldid=73983 * Chris Pressey * (+203) /* Syntax */ Describe the escape sequences allowed in string literals.
08:54:15 <esowiki> [[Language list]] https://esolangs.org/w/index.php?diff=73985&oldid=73951 * Chris Pressey * (+13) /* T */ Add Tandem.
09:04:32 <esowiki> [[Tandem]] https://esolangs.org/w/index.php?diff=73986&oldid=73984 * Chris Pressey * (+94) /* Examples */ Clarify why this example never matches.
09:04:43 <esowiki> [[GORBITSA]] https://esolangs.org/w/index.php?diff=73987&oldid=73980 * ZippyMagician * (+20) Fix to O/G commands
10:01:39 <esowiki> [[Tandem]] https://esolangs.org/w/index.php?diff=73988&oldid=73986 * Chris Pressey * (+42) /* Algebraic properties */ Don't let's confuse CNF and DNF.
10:03:07 <esowiki> [[BF-ASM:8]] M https://esolangs.org/w/index.php?diff=73989&oldid=73832 * DmilkaSTD * (+622) some documentation things
10:03:45 <esowiki> [[BF-ASM:8]] M https://esolangs.org/w/index.php?diff=73990&oldid=73989 * DmilkaSTD * (+18) Whoops
10:12:19 <esowiki> [[GORBITSA]] https://esolangs.org/w/index.php?diff=73991&oldid=73987 * X39 * (+4117) Made Specification into table with proper MUST/SHOULD/UNDEFINED/MAY/MUSTNOT verbs
10:16:25 <esowiki> [[GORBITSA]] https://esolangs.org/w/index.php?diff=73992&oldid=73991 * X39 * (+62) Renamed Headers
10:16:38 -!- Sgeo has quit (Read error: Connection reset by peer).
10:17:30 <esowiki> [[BF-ASM:8]] M https://esolangs.org/w/index.php?diff=73993&oldid=73990 * DmilkaSTD * (+105) comments syntax
10:20:07 -!- S_Gautam has joined.
10:20:26 <esowiki> [[GORBITSA]] https://esolangs.org/w/index.php?diff=73994&oldid=73992 * X39 * (+355) /* Specification */ Added details about initial values
10:29:25 -!- TheLie has joined.
10:43:14 -!- arseniiv has joined.
11:02:00 <cpressey> I just realized that enqueuing an event in a language like JavaScript is a lot like prepending a call frame to the bottom of the call stack. When the last function returns, instead of exiting (transferring control back to the OS), it transfers it to the event handler.
11:02:07 <cpressey> The analogy's not perfect of course.
11:05:18 <cpressey> I didn't realize until today that JavaScript's event queue actually contains the handlers themselves (I kind of thought there were looked up at the time the event is to be handled, but no. They're stored in the queue. If there is no handler, nothing's enqueued.)
11:06:51 <myname> that makes perfect sense since you can have multiple handlers created different ways for the same event
11:07:42 <cpressey> Yes, and there's no sense enqueing something if you know there's no handler for it.
11:11:02 <myname> yeah, especially since there are quite a lot of events that could happen
11:20:30 -!- user24 has joined.
11:21:04 <esowiki> [[GORBITSA]] https://esolangs.org/w/index.php?diff=73995&oldid=73994 * X39 * (+1074) Moved examples into table with according informations & expectations attached to them
11:21:52 <esowiki> [[GORBITSA]] M https://esolangs.org/w/index.php?diff=73996&oldid=73995 * X39 * (+14) /* Programs */ Added `Specification` to Compliance header
11:29:49 -!- Lord_of_Life_ has joined.
11:30:49 -!- Lord_of_Life has quit (Ping timeout: 264 seconds).
11:32:40 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
11:36:20 -!- cpressey1 has joined.
11:36:44 <esowiki> [[GORBITSA]] M https://esolangs.org/w/index.php?diff=73997&oldid=73996 * X39 * (+11) /* Implementations */ Updated input modes
11:37:13 -!- cpressey has quit (Ping timeout: 256 seconds).
11:51:23 -!- t20kdc has joined.
12:05:48 <esowiki> [[GORBITSA]] M https://esolangs.org/w/index.php?diff=73998&oldid=73997 * PythonshellDebugwindow * (+164) /* Programs */ eof cat
12:10:17 -!- cpressey1 has quit (Quit: WeeChat 1.9.1).
12:11:23 <esowiki> [[UsableSeed]] M https://esolangs.org/w/index.php?diff=73999&oldid=66292 * PythonshellDebugwindow * (+108)
12:16:59 <esowiki> [[User:PythonshellDebugwindow/InputOnlyLangs]] M https://esolangs.org/w/index.php?diff=74000&oldid=73787 * PythonshellDebugwindow * (+16)
12:19:03 -!- adu has joined.
12:21:34 -!- sprocklem has quit (Ping timeout: 240 seconds).
12:23:41 -!- sprocklem has joined.
12:29:00 <esowiki> [[GORBITSA]] https://esolangs.org/w/index.php?diff=74001&oldid=73998 * X39 * (-26) /* Programs */ Removed note that explains behavior according to specification
12:59:44 -!- S_Gautam has quit (Quit: Connection closed for inactivity).
13:09:37 <esowiki> [[Livefish]] M https://esolangs.org/w/index.php?diff=74002&oldid=73097 * PythonshellDebugwindow * (+21) /* Lua */ fix
13:14:18 -!- cpressey has joined.
13:21:20 <esowiki> [[GORBITSA]] https://esolangs.org/w/index.php?diff=74003&oldid=74001 * Geek Joystick * (+216) /* Programs */
13:35:54 <arseniiv> hi folks (hehe)
13:36:20 <esowiki> [[GORBITSA]] https://esolangs.org/w/index.php?diff=74004&oldid=74003 * ZippyMagician * (-1442)
13:37:50 <arseniiv> suppose you have a function `partition :: Integer -> [a] -> [[a]]` which for usual values of the first argument works like that:
13:37:50 <arseniiv> partition 3 [1..10] = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]
13:37:50 <arseniiv> what would you say about `partition 0`? (I have an answer of my own but I’ll spoil the problem later)
13:41:03 <myname> an infinite list of empty lists?
13:41:30 <arseniiv> yes this comes to mind immediately but I think this definition is quite unhelpful and there’s a better one
13:42:16 <arseniiv> which is coherent with definition of another function at 0, which is quite controversial for general public but algebraically solid
13:42:27 <arseniiv> I won’t spoil what function yet
13:43:39 <esowiki> [[Special:Log/move]] move * Ais523 * moved [[Sir Felix Delazar]] to [[User:SirFelixDelazar]]: appears to be a User: page created in the main namespace by mistake
13:43:46 <esowiki> [[GORBITSA]] M https://esolangs.org/w/index.php?diff=74006&oldid=74004 * ZippyMagician * (-10) Fix category in infobox
13:45:26 <esowiki> [[GORBITSA]] M https://esolangs.org/w/index.php?diff=74007&oldid=74006 * Ais523 * (+2) /* Implementations */ fix section header
13:45:40 <esowiki> [[GORBITSA]] M https://esolangs.org/w/index.php?diff=74008&oldid=74007 * ZippyMagician * (-10) Fix link
13:46:08 <esowiki> [[GORBITSA]] https://esolangs.org/w/index.php?diff=74009&oldid=74008 * Geek Joystick * (-103) /* Implementations */
13:48:45 <esowiki> [[GORBITSA]] https://esolangs.org/w/index.php?diff=74010&oldid=74009 * ZippyMagician * (+149) Add Multiplication programs
13:50:09 <esowiki> [[GORBITSA]] https://esolangs.org/w/index.php?diff=74011&oldid=74010 * ZippyMagician * (-67) Remove credits for non-major programs
13:50:18 -!- sprocklem has quit (Ping timeout: 256 seconds).
13:51:14 -!- sprocklem has joined.
13:55:27 <arseniiv> oh incidentally isn’t there a function in one of the bots which would post a message after a given timeout, or approximately at a given time?
13:55:51 <esowiki> [[GORBITSA]] https://esolangs.org/w/index.php?diff=74012&oldid=74011 * ZippyMagician * (+1) Fix
13:58:03 <cpressey> "partition 0" seems too much like "divide by 0" to me, I would leave it undefined
14:04:21 -!- user24 has quit (Quit: Leaving).
14:10:57 <esowiki> [[GORBITSA]] https://esolangs.org/w/index.php?diff=74013&oldid=74012 * Geek Joystick * (+388) /* Programs */
14:18:03 <esowiki> [[GORBITSA]] https://esolangs.org/w/index.php?diff=74014&oldid=74013 * ZippyMagician * (+17) Fix info/indentation
14:23:18 <esowiki> [[GORBITSA]] M https://esolangs.org/w/index.php?diff=74015&oldid=74014 * X39 * (+2363) /* Implementations */ Added more detailed info about supported IO
14:23:27 <ais523> well, it's obvious what the /last/ element of the resulting list is
14:23:43 <ais523> the only controversy is as to how many empty elements appear before it
14:24:02 <ais523> a naive implementation would surely put infinitely many empty elements there, though
14:24:04 <esowiki> [[GORBITSA]] M https://esolangs.org/w/index.php?diff=74016&oldid=74015 * X39 * (+6) /* Implementations */ Fixed INN & PNN
14:24:16 <ais523> (unless this is one of those "9 recurring = minus 1" theorems)
14:24:35 <ArthurStrong> ais523: thanks!
14:26:37 <ais523> thinknig about it, the number of elements that appear earlier should be 0/0, which is NaN, so I'm going to claim "the output is a list consisting of NaN empty lists followed by the original list"
14:26:54 <ais523> not that this is a concept that most languages can easily represent :-D
14:29:26 <ais523> …I guess a further ramification of this is that the output does not compare equal with itself
14:29:38 <esowiki> [[GORBITSA]] https://esolangs.org/w/index.php?diff=74017&oldid=74016 * Geek Joystick * (-1)
14:32:06 <esowiki> [[GORBITSA]] https://esolangs.org/w/index.php?diff=74018&oldid=74017 * ZippyMagician * (+0) Fix Zippy's implementation details
14:36:18 <esowiki> [[GORBITSA/bf-interpreter]] N https://esolangs.org/w/index.php?oldid=74019 * ZippyMagician * (+10779) Created page with "Created by Gorbit99. Runs in ROM mode with char input/output, only positive numbers allowed (0-255) >+[ Read in code until # ,>+++++++[-<----->]< [ If not # >>+< Set..."
14:36:49 <esowiki> [[GORBITSA]] https://esolangs.org/w/index.php?diff=74020&oldid=74018 * Geek Joystick * (+9) /* Implementations */
14:37:13 -!- LKoen has quit (Remote host closed the connection).
14:41:26 <esowiki> [[GORBITSA]] https://esolangs.org/w/index.php?diff=74021&oldid=74020 * SirFelixDelazar * (+20) /* Implementations */
14:41:54 -!- sprocklem has quit (Ping timeout: 240 seconds).
14:42:45 <esowiki> [[GORBITSA]] https://esolangs.org/w/index.php?diff=74022&oldid=74021 * SirFelixDelazar * (+22) /* Implementations */
14:43:23 -!- sprocklem has joined.
14:43:27 <esowiki> [[GORBITSA]] M https://esolangs.org/w/index.php?diff=74023&oldid=74022 * X39 * (+0) /* Implementations */ Updated my implementation details
14:45:59 -!- Arcorann has quit (Read error: Connection reset by peer).
14:47:23 <esowiki> [[GORBITSA]] https://esolangs.org/w/index.php?diff=74024&oldid=74023 * ZippyMagician * (+368) Add brainfuck interpreter
14:48:14 <esowiki> [[GORBITSA]] M https://esolangs.org/w/index.php?diff=74025&oldid=74024 * ZippyMagician * (+5) Fix link
15:11:04 <esowiki> [[GORBITSA]] M https://esolangs.org/w/index.php?diff=74026&oldid=74025 * Megarev * (+106) /* Programs */
15:13:13 <arseniiv> ais523: yeah something like that
15:14:01 <arseniiv> <cpressey> "partition 0" seems too much like "divide by 0" to me, I would leave it undefined => understandable
15:14:30 <arseniiv> <arseniiv> ais523: yeah something like that => I meant the first version where there are zero []s, though NaN []s is interesting
15:15:08 <esowiki> [[GORBITSA]] M https://esolangs.org/w/index.php?diff=74027&oldid=74026 * Megarev * (+4) /* A 10x10 Box (By Megarev) */
15:16:32 <esowiki> [[GORBITSA]] M https://esolangs.org/w/index.php?diff=74028&oldid=74027 * Megarev * (+67) /* A 10x10 Box (By Megarev) */
15:17:49 -!- ChanServ has set channel mode: +o ais523.
15:18:05 <ais523> not doing any moderation, but ChanServ is apparently going to go down for a while
15:18:30 <ais523> meaning that it'll be helpful to have someone pre-opped just in case op powers are needed
15:18:45 <ais523> otherwise there'll be no way to moderate the channel
15:19:25 <arseniiv> too reasonable to be the truth^W^W^W^W^W^W
15:19:55 <ais523> is x % 0 normally considered undefined? I can't see how it would have any sensible value but x
15:20:53 <arseniiv> ais523: yeah when I finally learned it may be defined as x, now I don’t see anything other else, but the majority of, say, programming languages conservatively/still-unknowingly disagrees
15:21:10 <ais523> it may depend on what edge case rules you use
15:21:27 <Taneb> ais523: it's undefined in C99 at least
15:21:34 <ais523> I just checked the specs of a language I'm working on and it said that the return value of a modulus x % y is always in the range 0 to y-1 inclusive
15:21:57 <ais523> which means that it needs to reject x % 0 as a range error, but then it also rejects x % -1 as a range error
15:22:05 <ais523> whereas I think most programming languages return 0 for integer x
15:22:13 <ais523> > 2 `mod` -1
15:22:16 <lambdabot> error:
15:22:16 <lambdabot> Precedence parsing error
15:22:16 <lambdabot> cannot mix ‘mod’ [infixl 7] and prefix `-' [infixl 6] in the same in...
15:22:19 <esowiki> [[GORBITSA/bf-interpreter]] M https://esolangs.org/w/index.php?diff=74029&oldid=74019 * PythonshellDebugwindow * (+49)
15:22:20 <ais523> > 2 `mod` (-1)
15:22:22 <lambdabot> 0
15:22:25 <ais523> > 2 `rem` (-1)
15:22:27 <lambdabot> 0
15:22:45 <arseniiv> I like Knuth’s definition IIRC, though I think there were arguments for another one which is close but it works with euclidean algorithm, I always forget in what regard
15:23:00 <ais523> (this is a language where having controlled errors is useful, so I don't want to make more cases work than are necessary)
15:25:05 <rain1> what's the argument for x % 0 = x?
15:25:45 <ais523> (x / y) * y + (x % y) = x
15:26:00 <ais523> with y = 0, the * y becomes * 0
15:26:04 <ais523> so you get (x % y) = x
15:26:10 <ais523> err, (x % 0) = x
15:26:16 <rain1> How is it that (x/0)*0 = 0?
15:26:37 <ais523> the argument relies on the identity z*0 = 0 for all z
15:26:44 <ais523> this is the only weak point in it
15:27:01 <ais523> in that it's quite reasonable to claim that that identity is unreasonable where division by zero is concerned
15:28:20 <arseniiv> rain1: you may first define mod n as a function from Z to Z/nZ (or e. g. from R to R/nR) with some properties, in this case mod 0 is Z → Z/0 ≅ Z and is the identity. Then you can map Z/nZ to Z in some way, like the usual [0..n) for nonzero n, but for n = 0, the all of Z will still be reasonable
15:28:44 <rain1> ooh
15:28:47 <arseniiv> with some properties => why, this should just be a ring morphism
15:28:47 <ais523> for what it's worth, in declarative languages, it seems obviously correct to have x / 0 = fail for nonzero x, and 0 / 0 = unconstrained number
15:28:59 <arseniiv> nonzero*
15:29:12 <ais523> in that case, x % 0 = x is the only consistent ruling if you're dealing with numbers that can go both negative and positive
15:29:53 <ais523> I haven't really decided how to deal with negative numbers in my declarative languages yet
15:30:02 <ais523> even Prologs differ amongst themselves
15:31:20 <arseniiv> <arseniiv> nonzero* => I’m not sufficient again; it should be an epimorphism
15:31:25 <cpressey> fwiw, Wikipedia's definition of modular arithmetic says "Given an integer n > 1, called a modulus, two integers are said to be congruent modulo n if n is a divisor of their difference, that is, if there is an integer k such that a − b = kn." If you ignore the n > 1 part, it's consistent with the choice x % 0 = x.
15:31:36 <cpressey> (No matter how much it offends my sensibilities.)
15:31:55 <arseniiv> cpressey: yeah, that’s indeed consistent
15:31:59 <ais523> I'm fairly satisfied that x % 0 can't reasonably be anything /but/ x, if it's anything at all
15:32:06 <ais523> but I think deciding that it's undefined is also reasonable
15:32:08 -!- adu has quit (*.net *.split).
15:32:08 -!- t20kdc has quit (*.net *.split).
15:32:09 -!- Phantom__Hoover has quit (*.net *.split).
15:32:09 -!- wmww has quit (*.net *.split).
15:32:10 -!- xelxebar has quit (*.net *.split).
15:32:12 <ais523> and the choice may depend on the domain of x
15:32:26 -!- adu has joined.
15:32:27 -!- t20kdc has joined.
15:32:27 -!- Phantom__Hoover has joined.
15:32:27 -!- xelxebar has joined.
15:32:27 -!- wmww has joined.
15:32:43 <arseniiv> more elaborated, (x % n = y % n) <=> (x ≡ y (mod n)) holds with this definition of %
15:33:06 <ais523> is (mod 0) generally considered defined?
15:33:14 <ais523> also, does this work for negative n?
15:33:29 -!- xelxebar has quit (Max SendQ exceeded).
15:33:32 <ais523> (that said, negative moduli are a mess anyway)
15:33:54 -!- xelxebar has joined.
15:34:22 <arseniiv> ais523: yeah, (mod −n) should be the same as (mod n), as (−n)Z = nZ, though I don’t know how widely that’s avoided in usage
15:35:33 <arseniiv> algebraically, ≡ (mod n) is the same as ≡ (mod I) for an ideal I = nZ. These relations are defined for any ideal, the same as we can have (mod [a normal subgroup]) for groups
15:36:02 <arseniiv> there should be no conflations in using this notation this way IIRC
15:36:16 -!- tswett[m] has quit (Ping timeout: 244 seconds).
15:36:27 -!- wmww has quit (Ping timeout: 252 seconds).
15:36:39 <arseniiv> I know very little algebra
15:38:51 <ais523> I know enough to quotient by an equivalence relation, and then wrote all my papers in terms of that
15:39:27 -!- xylochoron[m] has quit (Ping timeout: 240 seconds).
15:40:05 <cpressey> This week I designed a rewriting language and I think the set of rewrite rules forms a Kleene algebra.
15:40:12 <cpressey> I put it on the wiki this morning.
15:40:44 <cpressey> (Notwithstanding that I probably know less algebra than either of you)
15:40:45 <arseniiv> but that one should be consomething with all the structure, though I need to say I don’t understand why do many textbook authors not mention equivalence relations when defining quotient groups, rings and algebras
15:41:06 <ais523> wow that was annoyingly difficult to find in Recent Changes
15:41:13 <ais523> there's been so much activity recently
15:41:20 <arseniiv> though they won’t be able to avoid it if they choose to work with monoids or rigs heheheheh
15:41:57 <arseniiv> cpressey: ais523: what’s it called?
15:42:21 <cpressey> arseniiv: I think they prefer to speak in terms of homomorphisms, since it amounts to basically the same thing?
15:42:42 <ais523> arseniiv: https://esolangs.org/wiki/Tandem
15:43:18 <ais523> I also created an esolang recently, https://esolangs.org/wiki/Annihilator
15:43:36 <int-e> > 4 `mod` (-7) -- may use different representatives though
15:43:38 <lambdabot> -3
15:43:55 <arseniiv> cpressey: they like normal subgroups and ideals and that’s very good these things exist at all but sometimes they don’t, and anyways many quotient objects may be formulated as usual quotient sets with an induced structure, and that is the basic thing anyone needs to read stated in clear text, I think
15:44:11 <spruit11> > 4 `mod` 0
15:44:14 <lambdabot> *Exception: divide by zero
15:44:17 <ais523> > (-4) `mod` (-7)
15:44:19 <lambdabot> -4
15:44:23 <ais523> > (-4) `rem` (-7)
15:44:25 <lambdabot> -4
15:44:36 <ais523> > (-4) `mod` (7)
15:44:36 <arseniiv> I can’t get over The waterfall model still
15:44:38 <lambdabot> 3
15:44:40 <ais523> > (-4) `rem` (7)
15:44:43 <lambdabot> -4
15:45:03 <ais523> arseniiv: what bothers you about it?
15:45:29 <arseniiv> ais523: not that something bothers me, it’s just too neat a thing
15:45:35 <ais523> actually, the main thing that bothers me about it is that it was easier to prove TC than it should have been
15:45:35 <cpressey> arseniiv: I do agree that a clear explanation of quotients in abstract algebra would be nice to have and I've never really seen one; I'm still pieceing the ideas together, myself.
15:45:43 <ais523> which suggests that maybe there's an even simpler language along those lines
15:45:58 <arseniiv> how that was discovered that recently is strange!
15:46:05 <ais523> normally the easiest-to-implement languages are things like 2-Echo Tag which are a complete pain to prove
15:46:20 <ais523> arseniiv: and I discovered it at least twice before I noticed, possibly three times
15:46:23 <arseniiv> <ais523> which suggests that maybe there's an even simpler language along those lines => that would be even more mesmerizing
15:47:22 <ais523> one thing I noticed is that The Waterfall Model can trivially implement linear recurrence relations, but I suspect those aren't TC
15:47:28 <ais523> would be fun if they were though
15:48:09 <int-e> ais523: `rem` is the one that doesn't give representatives because it matches `quot` which rounds towards zero, whereas `div` rounds towards negative infinity (which is where a negative divisor makes a difference).
15:48:57 <ais523> right
15:52:47 <arseniiv> cpressey: the basic idea, for any algebraic model or even a structure with relations, is for the equivalence relation to be consistent (or what it’s called) with them, and that precisely gives us to induce that same kind of structure in the quotient set. Consistency is simple: ~ is consistent with a relation R iff (x1 ~ y1 and … and xn ~ yn) implies R(x1, …, xn) <=> R(y1, …, yn). For an operation, one just takes a corresponding relation: e. g.
15:52:47 <arseniiv> for + one takes (x, y, z) ↦ x + y = z. In general this would give us ~ is consistent with o when (x1 = y1 and … and xn = yn) implies o(x1, …, xn) = o(y1, …, yn)
15:56:52 <cpressey> arseniiv: yeah, I think I get it at this point, but it's taken me a while to get to this point. As I see it it's a homomorphism, and as such it has to preserve the properties of all of the operators. Which is a bit annoying in my particular application of it - some of those operators aren;t really relevant in the quotient algebra - I guess I have to say they're still there but we can safely ignore them
15:57:03 <arseniiv> that tells us that we can unambiguously define a relation or an operation on equivalence classes (by their representatives), and AFAIK this is the most general condition for that
15:57:43 <cpressey> alas, I must be off now - have a good weekend
15:57:44 -!- cpressey has quit (Quit: WeeChat 1.9.1).
15:57:45 <arseniiv> <cpressey> yeah it taken me too a while to recognize all the cogs underlying
15:58:02 <arseniiv> @tell cpressey have a good one too!
15:58:02 <lambdabot> Consider it noted.
15:59:22 <esowiki> [[GORBITSA]] https://esolangs.org/w/index.php?diff=74030&oldid=74028 * ZippyMagician * (+4) /* Programs */
16:04:25 <arseniiv> what I like is how one can overgeneralize this framework to structures which have several carriers and also maybe “constant domains” which are the same for any structure of this type
16:05:26 <arseniiv> in operations and relations’ signatures, carriers would be like type variables and the latter domains would be like type constants
16:06:46 <arseniiv> in this way we could say metric spaces are certain instances of this kind of structure. where there are a carrier X and a constant domain R involved. Though I think isometries are still more refined that morphisms for that kind of structure, I should check
16:07:54 <arseniiv> also maybe one could incorporate topological spaces and confluence spaces and whatnot in this framework too, using a more elaborate language in signatures
16:09:32 <arseniiv> as it’s particularly well-known that dependent types help describing axioms of the structure in its definition directly (with all the operations and relations), so maybe some higher types may allow describing these spaces in the analogous manner
16:09:50 <arseniiv> not that it’s useful by itself of course
16:25:05 <arseniiv> ais523: at [x], [y], when x is called in [x], shouldn’t the result be [], [a b z], [b a z], [y]? (in the article, there’s [x] instead of []). If so, maybe you wanted to define x as x in the first definition?
16:26:57 <esowiki> [[Annihilator]] https://esolangs.org/w/index.php?diff=74031&oldid=73920 * Ais523 * (+5) /* Example */ fix thinko
16:27:11 <esowiki> [[Annihilator]] https://esolangs.org/w/index.php?diff=74032&oldid=74031 * Ais523 * (+5) /* Computational class */ here, too
16:27:20 <ais523> arseniiv: yes, sorry
16:27:33 <ais523> this sort of thing is common when you design an esolang in your head and don't have an implementation
16:27:42 <arseniiv> yeah
16:27:56 <arseniiv> I think I ended up much the same way many times
16:28:21 <ais523> some of my esolangs are designed to investigate profound ideas in computation, or for proving things TC, or whatever
16:28:34 <ais523> but some are just random ideas that I thought it would be interesting to document, and Annihilator is one of those
16:29:10 <arseniiv> the last one which is finite state (thank to int-e’s good eye) is an example of that: initially I defined things in such a way a program only returned 0 (if halted)
16:29:47 -!- gitlogger has joined.
16:30:20 -!- kspalaiologos has joined.
16:30:27 <esowiki> [[GORBITSA]] M https://esolangs.org/w/index.php?diff=74033&oldid=74030 * PythonshellDebugwindow * (+83) /* Cat program */
16:37:26 <esowiki> [[Gecho]] M https://esolangs.org/w/index.php?diff=74034&oldid=70798 * PythonshellDebugwindow * (+50) link + cats
16:40:33 <esowiki> [[Category:Finite state automata]] M https://esolangs.org/w/index.php?diff=74035&oldid=22635 * PythonshellDebugwindow * (+23) cat
16:42:21 <esowiki> [[BFStack]] M https://esolangs.org/w/index.php?diff=74036&oldid=73005 * PythonshellDebugwindow * (-1) rm period
16:44:19 -!- b_jonas has joined.
16:45:30 <b_jonas> what the heck happened while I wasn't here? https://esolangs.org/logs/ webpage is unreachable (ping fizzie) and https://github.com/KrzysztofSzewczyk/esologs/ is missing two or three days
16:46:22 <kspalaiologos> ugh
16:46:23 <kspalaiologos> no idea
16:47:05 -!- TheLie has quit (Remote host closed the connection).
16:47:05 <ais523> clog is still here, so presumably it was logging
16:47:35 <ais523> yep
16:49:06 <kspalaiologos> I've filled my log gaps
16:49:58 <kspalaiologos> and I know the reason - a netsplit
16:50:15 <kspalaiologos> my bot has died because I didn't yet set up a reliable way of automagically getting it up (lol)
16:55:04 -!- gitlogger has quit (Remote host closed the connection).
16:55:21 <b_jonas> kspalaiologos: I see
16:55:36 <b_jonas> thanks
16:55:38 <kspalaiologos> done
16:55:41 -!- gitlogger has joined.
16:55:46 <kspalaiologos> the bot will no longer die on netsplits
16:55:48 <kspalaiologos> and it will rejoin
16:55:51 <b_jonas> nice!
16:55:55 <kspalaiologos> some stupid perl engineering
16:56:08 -!- TheLie has joined.
16:56:30 <b_jonas> just make sure the rejoin has some reasonable limits and sleeps so it doesn't fall into one of those stupid reconned-rejoin-die loops that some bots fall into
16:57:03 <kspalaiologos> it's done using a lock file
16:57:16 <kspalaiologos> when the bot quits, it's removing the lock file, and when it's ran, it creates a lock file
16:57:41 <kspalaiologos> the update.pl script (I put it in cron and it will run every 30min) will push the logs to github AND re-run the bot if the lock is missing
16:57:56 <b_jonas> kspalaiologos: sure, but I mean a loop with like reconnecting successfully every 10 minutes for three hours, after which a mod wakes up and bans them
16:59:17 <b_jonas> even every 30 minutes might be a problem if it does so indefinitely, because this channel is often slow with mods
16:59:44 -!- sebbu2 has changed nick to sebbu.
16:59:46 <kspalaiologos> I'll add reconnection attempts
17:00:13 <b_jonas> ideally you probably want some kind of incremental timeouts, where it reconnects immediately the first time, but then with progressively more sleep, and after like 14 attempts it waits a day between reconnections
17:00:34 -!- kspalaiologos has quit (Read error: Connection reset by peer).
17:02:23 -!- kspalaiologos has joined.
17:02:26 <kspalaiologos> my IRC client crashed
17:02:34 <ais523> reconnecting once every half hour doesn't seem excessively spammy to me?
17:02:52 <kspalaiologos> anyways, I've added a mechanism that will stop attempting after there have been 5 reconnect attempts before
17:02:58 <ais523> that's 48 quitjoins a day, there's normally much more conversation than that
17:02:59 <kspalaiologos> and it will drop me an e-mail
17:03:11 <b_jonas> ais523: it's probably borderline
17:03:21 <b_jonas> on some days we have very little traffic
17:03:21 <ais523> make sure it doesn't email you every half-hour, that can get annoying quickly
17:03:30 <ais523> I once accidentally configured my server to email me every minute
17:03:49 <ais523> luckily I was online at the time and, unsurprisingly, noticed pretty quickly
17:04:17 <kspalaiologos> if it will mail me every half an hour, I'll notice it fsater
17:04:20 <ais523> and I run my own mailserver so there was no issue with address reputation as a consequence
17:04:28 <kspalaiologos> also, the counter zeroes, so 5 * 30min = 2,5h
17:04:41 <kspalaiologos> a mail every 2 and 1/2 hour isn't much trouble for me
17:05:09 <ais523> doesn't that mean it'll try to connect 4 times every 2½ hours?
17:05:36 -!- S_Gautam has joined.
17:06:23 <kspalaiologos> tries once => wait for 30 min => tries 2nd time => wait for 30min => tries 3rd time => wait for 30min => tries 4th time => wait for 30min => tries 5th time => errrr send me an email, stop attempting
17:06:28 <arseniiv> @tell cpressey wait, if R & R = 0 then 0 = (R | S) & (R | S) = R & R | R & S | S & R | S & S = R & S | S & R = R & S | R & S = R & S, is that right?..
17:06:28 <lambdabot> Consider it noted.
17:06:33 -!- S_Gautam has quit (Client Quit).
17:06:44 <kspalaiologos> if R&R=0 then R must be 0
17:06:59 -!- S_Gautam has joined.
17:07:04 <esowiki> [[Special:Log/newusers]] create * Gorbit99 * New user account
17:07:32 <ais523> not in Tandem, where R&R is artificially 0 because & is more like an exclusive-and
17:07:32 <arseniiv> kspalaiologos: hehe there’s another meaning to &, see https://esolangs.org/wiki/Tandem :)
17:07:38 <kspalaiologos> oh f.ck
17:07:43 <kspalaiologos> the bot spilled its stderr on my screen
17:07:58 <ais523> also, I love esolangs, they make concepts like "exclusive-and" viable
17:07:58 -!- S_Gautam has quit (Client Quit).
17:08:01 <kspalaiologos> I can't see anything
17:08:03 <kspalaiologos> did it quit?
17:08:17 <ais523> gitlogger is still online; is that your bot?
17:08:26 <kspalaiologos> yes, ah, I see the problem
17:08:27 -!- S_Gautam has joined.
17:08:28 <kspalaiologos> wchar print
17:08:51 <b_jonas> ais523: hmm, I thought you were working on one of these declarative languages, with the intent that it should be more expressive in a declarative way than Brachylog
17:10:01 <kspalaiologos> alright, /redraw fixes the problem
17:10:18 <ais523> b_jonas: yes
17:10:21 <arseniiv> @tell cpressey so AFAIU the R & R = 0 is always true only for atomic rules, but the example above shows complex rules won’t be annihilated when conjusquared
17:10:21 <lambdabot> Consider it noted.
17:10:52 -!- kspalaiologos has quit (Quit: leaving).
17:11:09 <ais523> arseniiv: is there actually a requirement for | to distribute over &?
17:11:34 -!- wmww has joined.
17:11:42 -!- kspalaiologos has joined.
17:11:55 <arseniiv> ais523: hm maybe not, I had read it in “Conjunction distributes over disjunction: Ri & (Rj | Rk) = (Ri & Rj) | (Ri & Rk) (and the other direction too, because it's commutative.)”
17:13:42 <arseniiv> wait, this is the needed distributivity, I thought there is the other one
17:14:07 <arseniiv> hm
17:15:08 <arseniiv> it should be formally proven in Agda^W^W
17:16:40 <arseniiv> were there languages like Tandem before? Seems very cool to me at the end
17:16:58 <ais523> what property of it do you consider interesting?
17:17:22 <ais523> there are certainly languages which play around in a similar space in terms of semantics, but they don't necessarily have the same properties that Tandem does
17:18:09 <arseniiv> I haven’t thought of rewriting many disjoint places before, though I can see it may be grown from my questions about rewriting S-expressions a while ago, dumb me
17:20:26 <arseniiv> also a while ago I made a string-rewriting thing which used if the rule was applied succesfully to continue applying following rules, though that wasn’t by all means minimal and I artifically bounded it to sub-TC by requiring placing a finite repeat count for each loop
17:20:39 <esowiki> [[Esolang:Introduce yourself]] https://esolangs.org/w/index.php?diff=74037&oldid=73967 * Gorbit99 * (+117)
17:20:49 <esowiki> [[GORBITSA]] https://esolangs.org/w/index.php?diff=74038&oldid=74033 * Gorbit99 * (-713) fixed some incorrect info
17:20:53 <arseniiv> I intended it to be a text-generating tool but it ended up unwieldy
17:21:12 <kspalaiologos> I spent too much time yesterday and two days ago figuring 3sp
17:21:42 <kspalaiologos> this language seems just... so volatile, so spaghetti-y that I can't find a good way of programming it other than either genetic algorithm OR compiling some predictable assembly into large-ass code
17:22:00 <ais523> the latter approach is the better one I think
17:22:04 <ais523> although, the hardest part is startup
17:22:12 <kspalaiologos> I'll end up with malbolge 2.0
17:22:21 <kspalaiologos> with programs being bigger than the observable universe
17:22:24 <ais523> which places some fairly extreme constraints on your program because the startup code has to run every iteration
17:22:38 <kspalaiologos> I did such a thing with asm2bf while implementing labels
17:22:45 <kspalaiologos> the entire code runs inside a large loop
17:23:02 <ais523> start with "freestart 3*", where you get to initialize memory as you like separately from the program, as a wimpmode
17:23:10 <ais523> that isn't too hard to program in once you see the tricks
17:23:19 <arseniiv> <kspalaiologos> with programs being bigger than the observable universe => hm that gives an idea of executing compressed programs... surely some languages would allow that?
17:23:19 <kspalaiologos> it's 100% doable, but I just can't notice some things
17:23:38 <kspalaiologos> if you managed to write a good malbolge interpreter that would run my programs compressed
17:23:40 <ais523> arseniiv: in https://esolangs.org/wiki/Tip the program is infinitely long, but compresses well
17:23:49 <kspalaiologos> I'd really really appreciate it :p
17:24:06 <ais523> what sort of repetition normally exists within your programs?
17:24:14 <kspalaiologos> my malbolge programs? no-ops
17:24:26 <kspalaiologos> to nail the memory adresses
17:24:30 <ais523> do they execute/get encrypted? or are they jumped over?
17:24:38 <esowiki> [[User:PythonshellDebugwindow/Sandbox]] M https://esolangs.org/w/index.php?diff=74039&oldid=73245 * PythonshellDebugwindow * (+8) force toc
17:24:41 <kspalaiologos> 50/50 I'd say
17:24:52 <kspalaiologos> you'd have to figure out what does each one do
17:24:59 <kspalaiologos> but I believe it's all doable
17:25:00 <arseniiv> kspalaiologos: no thanks :D I don’t even into Malbolge, I mean in the sense I don’t even remember how it works at all. It ciphers something and has several opcodes and that’s all I remember
17:25:10 <ais523> the hard part isn't so much running the compressed program, but updating it as it encrypts
17:25:15 <kspalaiologos> the malbolge code follows a lot of repetitions
17:25:20 <ais523> within the compressed program
17:25:33 <kspalaiologos> I mean, you could theoretically parse my malbolge programs into some form of readable assembly using regex
17:25:43 <kspalaiologos> because I haven't gone crazy on golfing the output
17:25:59 <esowiki> [[User:PythonshellDebugwindow/2001]] M https://esolangs.org/w/index.php?diff=74040&oldid=72878 * PythonshellDebugwindow * (+38) rdr
17:26:43 <kspalaiologos> I compile them from a very sophisticated assembly
17:26:54 <ais523> I'd say a "compressed Malbolge executor" would be trivial, with an appropriately designed compression format, if not for the fact that Malbolge is self-modifying and you need to remember in what ways the program has self-modified
17:26:56 <kspalaiologos> my current opus magnum is a forth-like interpreter in Malbolge
17:27:19 <kspalaiologos> it's overall around two megabytes of my handcrafted assembly code
17:27:28 <kspalaiologos> and it works, very slowly
17:27:37 <kspalaiologos> I've left a fact(4) program to run overnight
17:27:40 <kspalaiologos> and it produced correct result
17:27:49 <ais523> I wonder if it would be efficient to store the original program, plus a count of encryptions that have been performed on each memory cell, plus a separate sparse array for memory cells that have been modified directly
17:27:58 <ais523> and do dynamic RLE on the encryption counts
17:28:07 <kspalaiologos> I.. don't think so
17:28:26 <kspalaiologos> because Malbolge follows the von neumann architecture, so you store data with the code
17:28:34 <ais523> right, that's what the final array is for
17:28:35 <kspalaiologos> and the code can grow quite big
17:28:37 <arseniiv> I don’t even into Malbolge => am not*
17:28:45 <kspalaiologos> I mean - my malbolge programs often swap
17:28:50 <kspalaiologos> to produce a meaningful result
17:28:55 <kspalaiologos> and I have a machine with 16 gigabytes of RAM
17:29:08 <ais523> I think with most Malbolge programs, the proportion of the memory that is used as useful data is very small, right?
17:29:16 <kspalaiologos> yes
17:29:24 <kspalaiologos> if you find out the storage format, you're pretty much home
17:29:27 <ais523> it's almost all either a) padding, b) self-encrypting code where the encryption isn't useful it just happens
17:29:33 <esowiki> [[Template:Cs]] M https://esolangs.org/w/index.php?diff=74041&oldid=73533 * PythonshellDebugwindow * (+29)
17:29:34 <kspalaiologos> yes
17:29:50 <arseniiv> <kspalaiologos> my current opus magnum is a forth-like interpreter in Malbolge => wow
17:29:53 <esowiki> [[GORBITSA]] https://esolangs.org/w/index.php?diff=74042&oldid=74038 * Gorbit99 * (-5) typo
17:30:14 <ais523> and at any given instant in time, there are going to be large runs in the number of times that specific instructions have encrypted
17:30:34 <esowiki> [[Category:Particle automata]] M https://esolangs.org/w/index.php?diff=74043&oldid=8177 * PythonshellDebugwindow * (+33) cat
17:30:36 <kspalaiologos> yes, and a viable thing is also guessing the encryption patterns
17:30:40 <ais523> so if we just store it in terms of ranges, "from address 10000 to address 12345 every instruction has encrypted 5 times"
17:30:53 <ais523> then the encryption counts shouldn't need much memory to store
17:30:54 <kspalaiologos> like, if you place a no-op somewhere, after executing it can turn into a movd, a jump, a halt, and god knows what else
17:31:15 <kspalaiologos> when you're preserving functions, for example the movd wrapper, the movd is executed, and then it turns into a nop, and then back again
17:31:18 <kspalaiologos> that's called a cycle
17:31:22 <kspalaiologos> or at least that's how I call it
17:31:34 <kspalaiologos> I don't think there's proper terminology for malbolge
17:31:35 <ais523> working out what's in memory from original value plus encryption count is constant time, if the address hasn't been written through d
17:32:17 <ais523> …does anyone write Malbolge programs where addresses are written through d and /then/ encrypted?
17:32:59 <arseniiv> (BTW what would you advice when one does want to write a translator but doesn’t want to hand-wite a parser nor to use an existing parser framework nor to complete their own framework at last? Maybe there still is an option?)
17:33:04 <ais523> that seems a bit unlikely to me because it's a hard operation to make work, the original Malbolge intepreter actually segfaults if the written value is outside the ASCII range (presumably because the case was never tested)
17:33:25 <int-e> arseniiv: Train a neural network on examples ;-)
17:33:42 <ais523> arseniiv: haven't you excluded all the cases apart from persuading someone else to write a new parser framework and using that?
17:34:14 <arseniiv> ais523: oh! that’s an interesting case though I don’t want to go that way yet
17:34:27 <kspalaiologos> well, depends on what do you mean by this
17:34:43 <ais523> or, well, waiting for someone to write a new parser framework and using it
17:34:44 <kspalaiologos> for example, if I have a movd, I call it, and then restore the old instruction back
17:34:58 <kspalaiologos> that's not the most efficient approach, but it's simple and reliable
17:35:07 <kspalaiologos> so my proposition is
17:35:19 <ais523> actually, another option that isn't logically excluded is to abandon your own parser framework, write an entirely new one and use it, but it seems like more effort than the options that have already been excluded
17:35:33 <kspalaiologos> somehow finding out where the real instructions are stored, identify the calling and restoring code, and then build upon that to optimize real instruction calls
17:35:53 <ais523> ooh, I think I realised the right format for storing memory
17:36:06 <ais523> if a value is in the ASCII range, you store it as an encryption count, starting from some constant ASCII character
17:36:14 <ais523> if outside the range, you just store it as the number
17:36:19 <ais523> then you use some sort of dynamic RLE-ing
17:36:37 <arseniiv> ais523: hmmm hm I’ll go persuade some friends then :D // oh, that new idea is what I think I would end up doing some time after, though that new framework would be just a rewriting of the larger portion of the old and that’s definitely still a work so I procrastinate all I can
17:37:25 -!- Sgeo has joined.
17:37:27 <arseniiv> (also do you have a SAT solver somewhere inside, I didn’t think there can be so many missed perfectly valid alternatives at all :D)
17:37:53 <ais523> I was trying to run through the truth table in my head
17:38:04 <ais523> or, not the full table, but at least identifying the variables
17:38:11 <arseniiv> hm that’s particularly useful
17:38:20 <ais523> it's similar enough to esoprogramming that it didn't seem that much out of character
17:38:34 <esowiki> [[GORBITSA]] https://esolangs.org/w/index.php?diff=74044&oldid=74042 * ZippyMagician * (+159) Explanation
17:38:48 <arseniiv> yeah I even saw the contracted truth tables or what was they called, they can be useful for manipulating in the head
17:38:53 <int-e> arseniiv: it's like solving a Sudoku ;)
17:39:22 <arseniiv> int-e: the thing I don’t enjoy too much but do when there’s nothing else to do, yeah
17:40:43 <int-e> I'm no good at Sudokus, really. Fortunately there are plenty of other logic puzzles that exercise your internal SAT solver. :)
17:40:50 <arseniiv> (when there’s nothing else to do and a sudoku nearby; I won’t try googling one or downloading a sudoku app. Though once I had a good one in an old phone, which marked possible variations with a good clear font)
17:41:05 <arseniiv> int-e: lolol
17:41:20 <arseniiv> I should remember the “internal SAT solver” thing
17:41:42 <int-e> arseniiv: that was *your* idea
17:42:06 <esowiki> [[User:PythonshellDebugwindow/AllTheCats]] N https://esolangs.org/w/index.php?oldid=74045 * PythonshellDebugwindow * (+524) .
17:42:08 <arseniiv> I pretend it wasn’t
17:42:21 <arseniiv> ah
17:42:22 <esowiki> [[Talk:GORBITSA]] N https://esolangs.org/w/index.php?oldid=74046 * X39 * (+291) Created page with "== GORBITSA Program Format == It was never specified that GORBITSA format is as followed <blockquote>Instructions must be separated by spaces, an instruction consists of a val..."
17:42:46 <esowiki> [[Talk:GORBITSA]] https://esolangs.org/w/index.php?diff=74047&oldid=74046 * X39 * (+42)
17:42:46 <arseniiv> no, I phrased that sufficiently differently so I wouldn’t think this form all by myself
17:42:57 <arseniiv> so no you gen thanks after all
17:43:00 <arseniiv> get*
17:44:05 <esowiki> [[GORBITSA]] https://esolangs.org/w/index.php?diff=74048&oldid=74044 * X39 * (-48) /* Specification */ Fixed mistakes
17:46:25 -!- xylochoron[m] has joined.
17:46:25 -!- tswett[m] has joined.
17:47:09 <arseniiv> okay I think handcrafted top-down parsers aren’t yet too bad a taste, especially for a grammar like Tandem has
17:47:44 <arseniiv> also top-down parsing does seem like the thing most comfortable to do by hand
17:49:16 <fizzie> "Recursive descent" is the usual word, and they're pretty common to handcraft.
17:49:21 <fizzie> Go's parser is one of those.
17:49:27 <kspalaiologos> would someone like to proofread / help me making an interpreter for this: https://esolangs.org/wiki/Esofun
17:49:40 <kspalaiologos> ultimately I plan on creating _the ultimate_ golfing language
17:49:57 <arseniiv> also do you know Pratt parsers? I implemented a toy with them once but I think they aren’t much better in error reporting (and other UX things for a parser framework’s client) than other approaches so I ended up leaving them where they were
17:50:07 <int-e> kspalaiologos: pfft
17:50:43 <kspalaiologos> what :p
17:50:47 <arseniiv> kspalaiologos: but that description is still too long
17:50:51 <int-e> "ultimate <anything>"
17:51:05 <int-e> okay, *almost* anything
17:51:08 <arseniiv> the ultimate antepenultimatum
17:51:22 <kspalaiologos> it'd be ultimate due to it's design goals
17:51:23 <kspalaiologos> just look at them
17:51:50 <arseniiv> I like partial orders for the reason there may be more than one maximal elements :D
17:52:22 <int-e> kspalaiologos: I'll read it when I've found the ultimate natural number.
17:53:14 <int-e> . o O ( naming of art periods is silly, but I think we have not yet had an ultimate one. )
17:53:29 <ais523> I'm not too keen on stack-based golfing languages, they're great for linear programs in the linear-logic sense (i.e. programs where each input and intermediate value is used exactly once) but it's common to want to use values multiple times
17:53:50 <ais523> and stack-based languages often have to waste a considerable portion of their command-space expressing how that happens
17:54:08 <arseniiv> int-e: the historical periods too, though maybe they aren’t that bad in English and other languages, I didn’t look at these
17:54:36 <int-e> arseniiv: that's related, but art periods are more finely grained
17:54:47 <int-e> so the silliness becomes more obvious
17:55:44 <ais523> I also think that in golfing languages, it's normally a mistake for there to be any distinction between a string and a list of characters, or between a character and its codepoint (the only time when it isn't is if you have overloaded operators)
17:56:38 <kspalaiologos> ais523: I don't think so - stack based approach opens opportunities for tacit and concentative programming
17:56:49 <kspalaiologos> and so far it's been proven that these paradigms shine when it comes to code golf
17:56:52 <ais523> tacit languages normally don't have a stack
17:57:04 <arseniiv> <int-e> so the silliness becomes more obvious => also in different art forms they use the same word for different periods, AFAIR
17:57:11 <ais523> stacks aren't incompatible with the idea of tacit programming, but also aren't required
17:57:40 <kspalaiologos> forth is a tacit and concentative programming language
17:57:46 <kspalaiologos> so is J, APL, K and so forth
17:58:06 <ais523> forth isn't tacit in a way that saves bytes, though
17:58:41 <kspalaiologos> well, I plan on adding absurd amount of builtins
17:58:47 <kspalaiologos> triggered by various adverbs
17:59:01 <kspalaiologos> this makes me think that well, that's a lot of room for optimizations
17:59:01 <ais523> I'm actually going the other way with my golfing languages
17:59:12 <ais523> trying to reduce the number of builtins so that they can have shorter names
17:59:25 <kspalaiologos> then it's not good for golfing, because you'll get outgolfed by Mathematica
17:59:28 <ais523> but making each of them crazily context-sensitive to increase how powerful it is
17:59:43 <kspalaiologos> that's exactly like the adverb system works in my language.
18:00:01 <ais523> it's not that rare for a full program that does something in, say, Jelly to be shorter than the name of the builtin in Mathematica
18:01:08 <arseniiv> yep, Mathematica surely takes the eloquent path to naming
18:01:10 <kspalaiologos> sigh, Jelly
18:01:21 <ais523> anyway, one major category of builtins that doesn't seem to be mentioned is builtins with block arguments
18:01:23 <kspalaiologos> if mathematica has names like Jelly builtins, and had them triggered by adverbs
18:01:27 <kspalaiologos> then well
18:01:57 <ais523> most mathematica builtins take lots of parameters though, and need them to avoid being too inflexible
18:02:24 <kspalaiologos> 256 adverbs, 256 instructions = 65536 possible builtins to squish into the language
18:02:30 <arseniiv> are there golf languages utilizing Hindley—Milner typing? Though I think I asked that and someone answered already
18:02:37 <kspalaiologos> that you have accessible using two keystrokes
18:02:45 <kspalaiologos> and sometimes, in 70% of times, using a single keystroke
18:03:08 <ais523> arseniiv: I answered https://esolangs.org/wiki/Husk to a similar question
18:03:22 <arseniiv> kspalaiologos: but how would one program in it^W^W^W^W^W^W^W
18:03:44 <arseniiv> ais523: ah! thanks I think it was you that time even
18:03:51 <int-e> arseniiv: counting to 7 is too much to ask
18:03:51 <ais523> kspalaiologos: you can't have 256 of each and have them both accessible in a single byte
18:04:03 <ais523> unless you insist on having exactly one adverb on every instruction
18:04:10 <int-e> arseniiv: but I think you deleted everything except the kspalaiologos: part
18:05:15 <arseniiv> int-e: that’s intentional, yeah. Hm or I got lost in the semantics
18:05:21 <kspalaiologos> ais523: adverbs are toggle/set
18:05:29 <kspalaiologos> so you can have the adverb already set, so you don't have to type it again
18:05:41 <kspalaiologos> arseniiv: that's the only real problem
18:05:42 <ais523> kspalaiologos: how do you distinguish between an adverb and an instruction?
18:05:47 <kspalaiologos> programming will be hard as heck
18:05:48 <ais523> you can't have 256 of each
18:05:56 <ais523> you need a bit to say which is which
18:06:02 <kspalaiologos> ais523: no, you're getting it wrong
18:06:09 <kspalaiologos> let's use pseudocode
18:06:23 <kspalaiologos> "toggle adverb B; do operation; do operation;"
18:06:33 <kspalaiologos> 1st and 2nd operation will work with the adverb
18:06:36 <kspalaiologos> b toggled
18:06:42 <ais523> kspalaiologos: you have 256 "toggle adverb" bytes and 256 "do operation" bytes
18:06:48 <ais523> that's more than 256 possibilities for each byte
18:07:10 <kspalaiologos> or, in literal code, tB..
18:07:23 <kspalaiologos> instruction t toggles an adverb
18:07:34 <ais523> the total number of adverbs + the total number of instructions needs to equal 256, if you want an 8-bit character set
18:07:57 <kspalaiologos> I'm afraid that you can't parse this language without ambiguities
18:08:08 <ais523> oh wow, now /that's/ an interesting answer
18:08:24 <kspalaiologos> you're looking at this problem like, if B is an adverb I set with tB, B is not usable as an instructio
18:08:27 <ais523> if you can make that work, the language got a lot more interesting
18:08:31 <kspalaiologos> and this is false, because you can
18:08:56 <kspalaiologos> there are also tons upon tons of type corrections and most operations introduce automatic reduce
18:09:02 <kspalaiologos> because the main datatype is a stack of lists
18:09:03 <ais523> hmm, is "toggle adverb" an instruction?
18:09:22 <kspalaiologos> it's `t'
18:09:31 <kspalaiologos> inb4: you can have t as an adverb
18:10:02 <ais523> oh, I see
18:10:04 <kspalaiologos> current adverb list is in pont 5, any other adverb can be flipped, but it makes no sense, because it doesn't change anything
18:10:13 <ais523> so instead of 1 byte to toggle and 1 byte per instruction
18:10:22 <ais523> you need, in effect, 2 bytes to operate a toggle
18:10:28 <kspalaiologos> yes
18:10:29 <ais523> but the instructions are 1 byte each when not toggled
18:10:34 <kspalaiologos> yes
18:10:44 <kspalaiologos> I also plan on somehow optimizing the toggles for size
18:10:52 <ais523> I think this can be a sensible way to design a language
18:11:01 <ais523> although it's possible that your numbers are off
18:11:10 <kspalaiologos> I plan on adding the instruction that will unpack a character to bits
18:11:17 <ais523> 256 sets seems like it's maybe too much
18:11:19 <kspalaiologos> and then set the adverbs in given range with this
18:11:33 <kspalaiologos> that's why I'm allowing to set for example adverb state to a list
18:11:44 <kspalaiologos> so you can compress your adverbs and then unpack them in runtime, and pop it to the adverb list
18:11:45 <ais523> err, 2²⁵⁶ sets is definitely too much
18:11:54 <ais523> even though there will be a lot of overlap
18:11:57 <kspalaiologos> because there will be an instruction for compression/decompression
18:12:23 <kspalaiologos> I also plan on implementing logical date operations
18:12:33 <kspalaiologos> unlike literally any other non-eso language out there
18:12:36 <ais523> maybe just have 8 bits of adverbs, for a total of 256 instruction sets, and have the toggle instruction unpack a literal byte?
18:12:48 <kspalaiologos> that's one way to do it
18:12:54 <kspalaiologos> i'll consider it
18:13:53 <kspalaiologos> ah, and you can also bend the type correction rules
18:14:18 <kspalaiologos> and I plan on adding a builtin to override all the existing instructions via the link mechanism
18:14:38 <kspalaiologos> so that you can create a link bound to either an instruction or an ID, that will execute and then pass the control to another link
18:14:40 <kspalaiologos> with the same name
18:15:03 <kspalaiologos> so you could e.g. override 0 with f0RN
18:15:13 <kspalaiologos> this has no effect, but you could theoretically put something useful there
18:15:40 <kspalaiologos> you can also declare identifier links, not bound to an instruction, rather, an identifier
18:15:45 <kspalaiologos> that you can call using '. syntax
18:16:01 <ais523> I take it this is designed to be a golfing language for writing large programs, then?
18:16:15 <arseniiv> hm now I thought “simple complex” and suddenly there is an idea of writing programs as cell complexes
18:16:31 <kspalaiologos> well, yes
18:16:39 <kspalaiologos> because writing simple programs in it makes no sense
18:16:43 <kspalaiologos> but for large scale code golf, it's perfect
18:16:52 <kspalaiologos> and very competetive, because most of the times you can golf the hell out of the code
18:20:07 <kspalaiologos> imagine, you have to for example golf a SKI calculus evaluator
18:20:33 <kspalaiologos> it'd be quite easy with functional languages and all that fluff, but stuff like osable or jelly don't seem like they have a simply and small way of solving this problem
18:20:47 <kspalaiologos> while in this language, there's a high chance you'd get it done in well under 50 characters
18:21:08 <arseniiv> better, directed ones. Starting with 2-cells, one has a big selection of polygons to choose from, 3-cells may vary in form further, but maybe even with 2-complexes which consist of 0-, 1- and 2-cells, one can encode something in a good way. There can be edges (1-cells) which are attached only by one of their vertices, any number of this kind of edge sticking from any vertex. Maybe one could use boundary and coboundary operators to define actions… And
18:21:08 <arseniiv> maybe the state of a program can be made a form on the complex, or a collection of forms of all degrees (here, 0-, 1- and 2-, each on cells of a corresponding order). Hmm
18:21:11 <ais523> that seems like an interesting challenge, actually
18:22:39 <arseniiv> ais523: kspalaiologos: is there a way algebraic types could work in a golflang?
18:23:35 <kspalaiologos> that's a bit hairy when I think about it, but I guess it's doable
18:23:42 <ais523> what do you mean by algebraic types? sum types and product types?
18:23:56 <ais523> normally golflangs are untyped, so you just use heterogenous lists for everything
18:23:57 <arseniiv> tagged sum types
18:24:07 <arseniiv> with products in each alternative
18:24:08 <ais523> e.g. instead of a(1,2) you use ['a',1,2]
18:24:33 <arseniiv> though it can be tagged sums + products not packed together
18:24:42 <ais523> or, well, you use whatever representation gives you the shortest code, but golflangs are normally good at operating on lists even if they have distinguished elements
18:25:16 <arseniiv> I’d say heterogeneous lists would suffice if there’s something like pattern matching
18:26:17 <arseniiv> though I don’t think one can do something feasible without constructing case tables
18:26:25 <arseniiv> and they would take up space
18:26:39 <ais523> I'm thinking about how I'd write this program
18:26:47 -!- kspalaiologos has quit (Quit: leaving).
18:27:00 <ais523> my current plan is to use executable code as the tags
18:27:15 <ais523> and just eval it to do the equivalent of the case table
18:27:26 <ais523> that works best if you have only one table, of course
18:28:28 <arseniiv> hm how frequently is there an instruction which takes [f, args…] to f(args…)?
18:28:50 <ais523> in Jelly it's a two-byter
18:29:13 <ais523> maybe a third when it's part of a larger program, to disambiguate what applies to what
18:29:40 <arseniiv> though one table constraint is not good for big tasks
18:29:46 <ais523> would be vḤ, I think
18:29:57 <ais523> no, other way round, Ḥv
18:31:00 <ais523> err, Ḣv
18:31:09 <ais523> like this: https://tio.run/##y0rNyan8///hjkVl////j1YPVtcx1DHSMY4FAA
18:56:38 <ais523> I guess you could simply use numeric tags, and index into a list of code fragments
19:00:16 -!- LKoen has joined.
19:08:50 <esowiki> [[GORBITSA]] M https://esolangs.org/w/index.php?diff=74049&oldid=74048 * Megarev * (+162) /* Programs */
19:09:07 <esowiki> [[GORBITSA]] M https://esolangs.org/w/index.php?diff=74050&oldid=74049 * Megarev * (+8) /* Cool Stairs (By Megarev) */
19:15:09 -!- S_Gautam has quit (Quit: Connection closed for inactivity).
19:34:34 <zzo38> I was working on my own golf programming language involving the PC character set
19:37:51 <zzo38> Its data types are: number (a rational number with an optional French suit), list (can contain data of multiple types), function, dictionary (key/value pairs with no duplicate keys), mark (there is only one kind of mark; this is similar to the mark in PostScript).
20:07:14 <ais523> SKI combinator calculus in 40 bytes of Jelly, and I haven't really tried to properly golf it yet: https://tio.run/##y0rNyan8//9Rw5zDO47uebiz5XDLsU3JCUD@o6Y1D3fMBzIOLX7UMPPhzmYgs@zhju0Pd@57uHOWjrX@o4a5QPahJVz@D3d3H1p0aOvh@UA9ZfqHtvo83N11aKv9////o6Oj1YvVddQz1WMhBDI/Wz02FgA
20:07:52 <ais523> or to write the program itself, “øżṄÄƲc`“€ḟ“£’ṃ“vḷṾṚ,;/”Ṿ¤¶Oị¢µß€v/µLỊµ?
20:09:49 <ais523> evaluation is eager, function before argument; it goes into an infinite loop (sadly not tail-recursive) if the SKI term doesn't normalize, or prints out some Jelly code that implements the function in question if it does normalize
20:11:35 <ais523> come to think of it, this also shows why writing golfing languages designed for large programs is kind-of pointless: you could instead write a small decompressor and use eval, as is done here
20:13:22 <esowiki> [[Beautiful day]] N https://esolangs.org/w/index.php?oldid=74051 * Hakerh400 * (+2098) +[[Beautiful day]]
20:13:25 <esowiki> [[Language list]] https://esolangs.org/w/index.php?diff=74052&oldid=73985 * Hakerh400 * (+20) +[[Beautiful day]]
20:13:30 <esowiki> [[User:Hakerh400]] https://esolangs.org/w/index.php?diff=74053&oldid=73775 * Hakerh400 * (+20) +[[Beautiful day]]
20:14:34 -!- ais523 has set channel mode: -o ais523.
20:14:38 <ais523> services should be working again now
20:16:17 <b_jonas> uh, that's a lot of scrollback I should read later. is there something that should really concern me?
20:16:51 <ais523> you mean from today? or from the earlier logs that have now been fixed?
20:16:59 <ais523> it's just been basic, on-topic conversation, there's just been a lot of it
20:17:06 <ais523> from today, at least
20:17:06 <b_jonas> from today, after I entered
20:17:26 <b_jonas> there wasn't much from before that, I looked at the one logs server that was still available
20:17:54 <b_jonas> only even though I was joined, I was looking at other more urgent stuff
20:22:00 <ais523> sadly Jelly's escaping syntax blows up exponentially, so my SKI interpreter in Jelly isn't going to work on nontrivial programs
20:27:00 -!- ais523 has quit (Quit: quit).
20:32:37 <t20kdc> looking at tio.run, I'm curious as to how the BitBitJump interpreter is supposed to work
20:32:58 <esowiki> [[GORBITSA]] https://esolangs.org/w/index.php?diff=74054&oldid=74050 * ZippyMagician * (+1113) Add tic-tac-toe example
20:34:21 <t20kdc> aaah, someone has created a standardized assembly notation for BitBitJump, that explains it
20:42:14 <esowiki> [[Beautiful day]] M https://esolangs.org/w/index.php?diff=74055&oldid=74051 * PythonshellDebugwindow * (+72) /* Interpreters */ cats
20:44:39 <esowiki> [[Special:Log/newusers]] create * TrolledWoods * New user account
20:46:42 <esowiki> [[Esolang:Introduce yourself]] M https://esolangs.org/w/index.php?diff=74056&oldid=74037 * TrolledWoods * (+95) /* Introductions */
20:49:57 <esowiki> [[GORBITSA]] https://esolangs.org/w/index.php?diff=74057&oldid=74054 * TrolledWoods * (+361) /* Programs */
20:50:45 <b_jonas> "trying to reduce the number of builtins so that they can have shorter names" => does that really help? you can have lots of builtins but huffmanize them so that common ones are encoded to short names. you don't lose a lot by adding extra builtins with long names in a golf language.
20:51:19 <esowiki> [[GORBITSA]] https://esolangs.org/w/index.php?diff=74058&oldid=74057 * TrolledWoods * (+1) /* Saurons eye (By TrolledWoods) */
20:58:17 <b_jonas> kspalaiologos: but not many people actually do golfing on large programs (... says the guy who submitted a 202 byte program for a simple golf challenge)
21:03:16 <b_jonas> "<ais523> sadly Jelly's escaping syntax blows up exponentially" => that's sad. it's a pity that K&R didn't define a short escape syntax for a backslash in a string literal other than "\\", so now you can only use "\x5C" because nobody managed to standardize a short escape syntax later, by fear that nobody else would speak it
21:03:44 <b_jonas> and it might be too late because backslash followed by anything means something in some languages
21:04:05 <b_jonas> you can still define an escape syntax for your language, but not for anything that will spread and be uniform everywhere
21:04:29 <b_jonas> well, technically "\x5C" or "\??/"
21:07:07 <b_jonas> or "\134" I guess, but "\x5C seems the best option
21:07:17 <b_jonas> so that's what I usually use
21:29:40 -!- TheLie has quit (Ping timeout: 244 seconds).
21:39:24 <esowiki> [[GORBITSA]] M https://esolangs.org/w/index.php?diff=74059&oldid=74058 * X39 * (+1) /* Specification */ Fixed Typos
21:45:34 <arseniiv> b_jonas: how do you think, is there a better way to escape a character than x ↦ xx, xx ↦ xxx, xxx ↦ xxxx?
21:47:49 <b_jonas> arseniiv: that would be ugly, how would you put a different escape starting with x after that?
21:48:22 <arseniiv> xxxxxd?
21:48:31 <arseniiv> ah
21:48:34 <b_jonas> but how do you distinguish wh...
21:49:57 <arseniiv> hm it seems a while ago I ended up with a way both unambiguously parsable and resembling this one
21:50:04 <b_jonas> ideally K&R should have said something like \m is an escape for a backslash, and then everyone copies that together with \n and \t, and perl's and php's quoting functions would turn a backslash to that
21:50:45 <b_jonas> and then \mm is a two-level escape of a backslash, while \m\m is an escape for two backslashes, \mn is a double escape for a newline etc
21:51:25 <arseniiv> ah, yeah, \ \m \mm \mmm is the way I think that was
21:53:19 <arseniiv> what would you suggest for the case of paired characters? Like, in C# and newer Python3 there are `{` and `}` in format strings, which escape as `{{` and `}}`. This explodes as well as `\\`
21:54:03 <b_jonas> in some dump files that I both write and read, I use an escape format where "\x10" is an escape character, to unescape remove it and xor the next byte with 0x20, so a line feed is escaped by "\x10J" and the character itself is escaped as "\x10P", and I use "\x1F" as the string delimiter and if that one came up in a string that would be escaped as "\x10_" too
21:54:43 <b_jonas> for something like C/perl/php/sql source code I wouldn't recommend this, you want them to be printable ascii rather than control characters
21:55:14 <arseniiv> b_jonas: how do you read those files though?
21:55:55 <b_jonas> arseniiv: I hate python's format string syntax in first place, for reasons unrelated to that escape syntax, but luckily python also offers a more traditional format mechanism with a format syntax like C's printf, so that's what I always use
21:56:49 <b_jonas> arseniiv: what do you mean how I read them? I either read them with perl or python scripts where I have a function that does the unescaping, and they're easier to read than CSVs because I can read them line by line and a line break always means the end of the record with no mucking about with escaped line breaks,
21:57:03 <arseniiv> I advocated (and I think I still do) US, RS, GS and FS as a CSV replacement but unfortunately they aren’t printable either, though many editors would print them good, but the other issue people wouldn’t be able to input them well
21:57:24 <arseniiv> b_jonas: ah, I see
21:57:45 <b_jonas> or by eyeballing at them in a text editor, which displays control characters in some fancy way, and again it's easy because then there are no escaped line breaks, so every record is a single line
21:58:13 <b_jonas> I also work with CSVs, because I interface with existing programs that read and write them, and quoting line breaks is more ugly there
21:58:28 <arseniiv> US, RS, GS and FS => I need to add them to my AHK script, for some reason they aren’t there—at least to test various text editors
21:59:04 <arseniiv> yeah, escaped line breaks aren’t good for the eyes
21:59:15 <b_jonas> have you ever tried to implement a CSV reader and writer that handles quoted line breaks, quoted field separators, and quoted double quotes, correctly in all corner cases, including detecting malformed input and including accepting either "\n" or "\r\n" as the field separator but preserving the distinction between them inside quoted strings?
21:59:29 <b_jonas> I have written such a csv reader and writer, and I believe it's correct now, but it's UGLY AS HELL
21:59:37 <b_jonas> I hate whoever invented these quoting standards
21:59:58 <arseniiv> b_jonas: including detecting malformed input => hopefully I won’t need to do that!
22:01:29 <arseniiv> okay I suggest using `{|` and `|}` as escapes for `{` and `}` for example. Is it good?
22:01:31 <b_jonas> whereas the reader and writer for my dump format is trivial, so trivial that I implemented a writer even in VBA, which is such a horrible language that I choose dump everything and then process them in external code rather than try to implement anything nontrivial in VBA directly. I could similarly easily write a reader for this format in VBA, though I haven't done yet, and it would be trivial, at least
22:01:37 <b_jonas> the parsing and unescaping parts would be trivial.
22:02:02 <b_jonas> arseniiv: again, no clue, because I hate braced format strings in first place
22:02:48 <arseniiv> VBA is horrible, I agree as someone who wrote in it and in VB6 for some time when there was no internet access and prior to finding a CD with Delphi
22:03:20 <arseniiv> b_jonas: let’s pretend they aren’t for format strings
22:03:51 <arseniiv> though I won’t name another application from the top of the head
22:03:52 <b_jonas> though I haven't tried to use the foreign call interface of VBA yet, but maybe I should, linking a DLL and calling my own C functions might work better than dumping to a file in some cases
22:04:05 <b_jonas> I should definitely experiment with how easy or difficult that is
22:04:30 <b_jonas> arseniiv: no clue then, I can't really tell how you should escape something unless there's an actualy application that I can imagine
22:05:09 <b_jonas> meanwhile, I managed to cause a rules debate in the M:tG 3-card blind thread
22:05:11 <arseniiv> I think FFI declarations were more or less good but I didn’t write them those times, only marveled at someone’s registry access code from wherever
22:05:37 <arseniiv> VBA should interoperate well with COM+! (I’ll show myself out)
22:05:55 <b_jonas> I submitted a deck based on a judgement I received in a private message from the then GM in the previous thread, and the players somehow don't want to use that, despite that in general we use most of the rules from that thread.
22:06:48 <b_jonas> arseniiv: yes, if I was a windows programmer then I wouldn't even try to use VBA, just call the VBA interface of this application through some COM or whatever interface that is from a non-VBA program
22:06:54 <b_jonas> a C++ or C# program or something
22:07:13 <b_jonas> I know there's such an interface, but given that I'm not a windows program and don't want to become one, I have never learned how that thing works
22:07:47 <arseniiv> maybe C# would be better these times though I didn’t try, I avoid
22:08:16 <arseniiv> I mean I did try C# and wrote much in it but didn’t try connections of this sort
22:08:30 <b_jonas> it's still not ideal, because the application interface has a few functions that you can access from the UI and I really want to access them from VBA but there's no interface yet, plus a few of the interface functions have bugs
22:08:41 <b_jonas> but still much better than the terrible UI and trying to do everything manually with it
22:10:33 <zzo38> arseniiv: I have also thought to use US, RS, GS, FS, and the SQLite command-line interface supports this format, too.
22:11:05 -!- TheLie has joined.
22:11:12 <arseniiv> zzo38: neat! didn’t know, thanks
22:11:18 <zzo38> (And when doing that, I have used \x10 as an escape character, too)
22:13:13 <b_jonas> admittedly I cheat, and use a second escaping mechanism: "\x0B" is a one-byte escape for "\r\n", because that's by far the most common thing I have to escape
22:13:40 <b_jonas> but this doesn't change the properties of the format much, it's still very easy to write and read
22:14:45 -!- LKoen has quit (Quit: Leaving).
22:15:23 <arseniiv> interestingly, I see AHK pastes US and RS in full but stumbles on GS and FS for some reason
22:31:22 <arseniiv> if anyone’s interested how to add them to AHK, I found a simple and working way: send things like `{U+001c}` (this for FS)
22:35:55 <esowiki> [[Talk:Functional deadfish]] N https://esolangs.org/w/index.php?oldid=74060 * 20kdc * (+284) Note a possible spec flaw.
22:36:24 <b_jonas> arseniiv: what is "AHK"?
22:42:07 <arseniiv> b_jonas: AutoHotkey, a Windows automation tool which allows to define hotkey actions and send strings (aside other things). I use it with a large script to send almost all the unicode characters I post here and elsewhere, by typing LaTeX-like sequences (which wasn’t a good move but now I have what I have), like \rd␣ will send ⌟
22:42:36 <b_jonas> arseniiv: ok
22:42:59 <arseniiv> 12345 wow I accidentally used IRC formatting
22:43:11 <arseniiv> hm hm
22:43:45 <arseniiv> evidently FS…US are used for formatting here too. I thought that would be some other unprintable characters
22:44:25 <b_jonas> GG ohdeerK
22:44:52 <b_jonas> wrong channel
23:10:27 <arseniiv> rewritten the data model for cpressey’s Tandem almost two times now, it’s time to sleep…
23:15:13 -!- arseniiv has quit (Ping timeout: 264 seconds).
23:16:17 -!- TheLie has quit (Remote host closed the connection).
23:18:18 -!- heroux has quit (Ping timeout: 265 seconds).
23:22:44 -!- imode has joined.
23:28:44 -!- Lord_of_Life_ has joined.
23:29:57 -!- heroux has joined.
23:31:34 -!- Lord_of_Life has quit (Ping timeout: 260 seconds).
23:31:40 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
23:36:29 -!- tromp has quit (Ping timeout: 272 seconds).
23:46:07 <b_jonas> and... I accidentally spawned a small debate about US customary units :(
←2020-06-18 2020-06-19 2020-06-20→ ↑2020 ↑all