00:01:07 <imode> figured as much. iirc two states with some fenangling makes you TC.
00:01:37 <int-e> yeah, two states and sufficiently many symbols... hmm
00:01:39 <b_jonas> right, but see ais523's language https://esolangs.org/wiki/StackFlow for when you have multiple tapes, and you choose which one to read from in the next step in each step
00:02:05 <imode> huh. that's interesting.
00:02:37 * imode wonders if a two-tape one-state TM could be TC...
00:02:41 -!- xkapastel has quit (Quit: Connection closed for inactivity).
00:02:55 <int-e> ais523 is involved in https://en.wikipedia.org/wiki/Wolfram%27s_2-state_3-symbol_Turing_machine :P
00:03:10 <imode> naively you could store your current state in that alternate tape.
00:03:24 <imode> wait really? lmao.
00:03:31 <int-e> imode: in that case you can certainly use one tape to store the state of an ordinary TM.
00:03:42 <HackEso> Agent “Iä” Smith is an alien with a strange allergy to avian body covering, which he is trying to retroactively prevent from ever evolving. On the 3rd of March, he's lawful good.
00:03:52 <imode> useful information.
00:04:09 <int-e> it's more useful than you may think... the "Smith" is accurate.
00:05:12 <imode> that two-tape one-state idea has me thinking about rewrite languages and CAs now..
00:05:43 <shachaf> I can think of a good reason to have two active stacks for coroutines/asynchronous code. Is there ever a reason to have more than two?
00:06:12 <int-e> hmm... define "active"
00:06:41 <shachaf> I mean something like, you pass two stack pointers to procedures in two registers, and it's part of the calling convention or something.
00:06:51 <shachaf> It's not really a precise word.
00:07:00 <imode> you could use one tape as a buffer to hold the CA state along with markers around the start end end of the state... and you could swap between them based on whether or not you read the marker.
00:07:16 <int-e> if you have coroutines more than two of those may be involved in any particular computation and they may each want to do their own recursive stuff
00:07:41 <shachaf> Right, that's the kind of thing I was trying to avoid with the vague word "active".
00:08:13 <shachaf> It seems like the compiler/calling only ever has to know about two stacks, and the switching between them would be done in user code or something.
00:08:14 <int-e> generator ( | transducer )* | consumer
00:08:39 <imode> "If you read X from tape A, write Y to tape B, move head A right.", "If you read X from tape B, write Y to tape A, move head B right."
00:08:46 <shachaf> Also does anyone actually implement coroutines using two stacks?
00:09:09 <imode> I tend to prefer cooperative multitasking and use state machines.
00:09:33 <shachaf> I'm talking about cooperative multitasking, and about ways of expressing these state machines nicely.
00:09:51 <shachaf> Well, they're not finite state machines, because there's a stack. But you could bound the size of the stack and prohibit recursion.
00:10:02 <int-e> shachaf: why *two*?
00:10:33 <shachaf> Well, the usual implementation technique for coroutines involves only one stack. Right?
00:10:34 <int-e> each coroutine should have its own stack, in principle...
00:10:42 <shachaf> And then the context switch switches to a new stack.
00:11:01 <int-e> I don't know why you want to use two.
00:11:16 <shachaf> But then various things are stored in the coroutine stack that could just go on the main stack because they never yield.
00:11:42 <shachaf> Which means you get a lot of unnecessary cache misses, and also the stacks need to be bigger for no real reason.
00:12:30 <shachaf> You also get things like https://marcan.st/2017/12/debugging-an-evil-go-runtime-bug/
00:12:49 <int-e> Well if you like, Haskell does that... the "main" stack is almost exclusively for FFI; all the coroutine stacks are managed on the heap.
00:13:10 <shachaf> Yes, but if you're using Haskell you've already given up on performance.
00:13:51 <int-e> No, not really. I've given up a factor of 3-10, depending on what I'm doing. Less when working with big integers.
00:14:15 <shachaf> If you think about the "optimal" way of writing an asynchronous task, it probably involves giving the task some fixed-size block of memory, and doing regular computation in the regular stack.
00:14:57 <shachaf> I want to approach something like that but with nicer code.
00:15:21 <imode> I've been trying to work on a small-scale network of automata that can communicate.
00:16:00 <imode> cooperative multitasking with round-robin scheduling is pretty much my go-to. instead of trying to cram code into an automata framework, I'd rather just use automata.
00:16:33 <shachaf> Automata can be awkward to write.
00:16:51 <imode> true, but so can assembly.
00:17:10 <imode> the difference is that automata are composable. state tables can be arbitrarily wired up.
00:17:33 <shachaf> That's why I want something which is neither automata nor assembly.
00:17:44 <imode> you can build simple machines from smaller state tables.
00:17:51 <imode> and then more complex machines from those simple machines.
00:18:32 <int-e> So compile to state machines. I suspect that this is something people actually do in this context (for tightly coupled coroutines. not threads.)
00:18:58 <imode> exactly my thought. I'm planning on not breaking that thread of modeling, though. LSL from Second Life does some similar stuff.
00:19:19 <imode> meaning, every script is a state machine with some internal stuff. you have to model things in terms of states.
00:20:59 <int-e> shachaf: I actually think that the principle of the Haskell analogy is sound, that is, to manage a coroutine local stack on a heap, possibly as a linked list. In many cases where you care about performance this will degenerate into doing a single allocation of a block that stores all the state for the whole lifetime of the coroutine invocation.
00:22:25 <shachaf> Sure, the thing GHC does is more or less reasonable at a high level.
00:22:27 <int-e> To my mind the stack switching approach is mainly attractive because it doesn't require much (if any) compiler support.
00:22:44 <shachaf> If you had compiler support and also cared about performance, what would you do?
00:23:18 <shachaf> I think the answer would look a lot like having two stacks. Though maybe you should care about performance even more, prohibit recursion, and statically bound the size of the stack.
00:25:23 <int-e> https://www.youtube.com/watch?v=j9tlJAqMV7U was inspiring in this context.
00:26:09 <int-e> yes, but it's more about the power of static analysis
00:26:20 <shachaf> I think that might be in the right direction though I haven't looked at the details.
00:26:42 <shachaf> LLVM has a coroutine thing that looked reasonable at a high level though the details might've been a bit weird. I don't remember anymore.
00:33:13 -!- tromp has joined.
00:34:44 <int-e> Oh he gives a lot of talks. https://www.youtube.com/watch?v=_fu0gx-xseY may be the one that I actually watched? I don't recall precisely.
00:35:25 <shachaf> I can't watch a talk right now but I'll look later.
00:35:36 <shachaf> Is there a spoiler for why the overhead is negative?
00:37:28 -!- tromp has quit (Ping timeout: 246 seconds).
00:37:41 <int-e> My vague idea was that the compiler gets more information from statically analysing the coroutines than it did from analysing a hand-written state machine. And it did its own state-machine, while preserving the improved static analysis information.
00:39:07 <int-e> And I didn't think that the talk fully explained it. It does make for an amazing punchline though. ("We wrote high-level code, and the compiled result was better than our hand-optimized low-level (but still C++) code.")
00:40:46 <int-e> As far as I recall, this falls into the category where the coroutines are tightly coupled, and only need finite state.
00:42:49 <shachaf> I was kind of wondering whether this kind of thing can be implemented well as a pretty straightforward macro, but I think the answer is no, you want compiler support to do it well.
00:43:57 <shachaf> In this one collection of language ideas I've been trying to figure out, stack memory allocation for variables is explicit, alloca-style.
00:44:06 <b_jonas> shachaf: yeah, just "a pretty straightforward macro" is where all the downwards spirals to crazy preprocessing magic starts with
00:44:28 <shachaf> b_jonas: well, that's not straightforward anymore, is it hth
00:44:35 <int-e> . o O ( just a simple recursively defined template )
00:44:58 <shachaf> Something like "x := Var(int)", where x is a (const) pointer to a stack-allocated memory location.
00:45:11 <shachaf> Or "x := Var(0)" or whatever
00:46:45 <shachaf> But a thing like that isn't enough.
00:48:03 -!- oerjan has joined.
00:49:21 <int-e> http://www.afjarvis.staff.shef.ac.uk/sudoku/sudoku2.cc features a template <int x, int y> static inline void search();
00:50:02 <int-e> Which inspired the "just a simple recursively defined template" thought.
00:50:12 <int-e> 2005, so long ago...
00:50:30 <shachaf> I wish C++ had a way to pass an argument either at compile-time or at runtime.
00:51:19 <shachaf> For some reason C++ people love to do complicated recursive things with templates.
00:51:25 <shachaf> Rather than just, y'know, a for loop
00:52:43 -!- tromp has joined.
00:53:20 <int-e> Well that particular thing generates up to 81 nested for loops.
00:53:53 <int-e> But I'm not sure I would do it quite that way anymore. Probably not :)
00:54:37 <shachaf> i,i,i for (int i = 0; i < 81; i++) { printf("for (int i%d = 0; i%d < k; i%d++) {\n", i, i, i); }
00:56:20 <shachaf> What language is good at doing things like that? Plus isn't lisp.
00:56:45 <int-e> I'd happily use Haskell to generate C code.
00:56:58 <shachaf> I mean something slightly nicer than string generation.
00:57:10 <shachaf> More like quasiquoting, I guess?
00:57:20 <rain1> quasiquoting but not lisp? i don't know any
00:57:23 <shachaf> But statically typed with a reasonable idea of eventually generating a compiled program.
00:57:33 <rain1> i suppose metaocaml
00:57:38 -!- tromp has quit (Ping timeout: 268 seconds).
00:59:37 <int-e> http://hackage.haskell.org/package/inline-c maybe?
01:00:01 <shachaf> Also it's the same language as the language you're generating code for.
01:00:35 -!- xkapastel has joined.
01:01:48 <int-e> Template Haskell isn't all that bad. But it would defeat the purpose of generating nested loops for sudoku enumeration in the first place, which was performance. :P
01:02:10 <shachaf> counterpoint: template haskell is all that bad
01:02:18 <int-e> http://hackage.haskell.org/package/haskell-src-meta
01:03:53 -!- Essadon has quit (Quit: Qutting).
01:04:40 <shachaf> Have you used the fancy variadic templates in C++11?
01:33:04 <shachaf> I guess more widespread coroutines might be useful for other uses.
01:33:28 <shachaf> Possibly nicer than using callbacks for a lot of things?
01:33:45 <shachaf> Say, a function that wants to request more memory from the caller mid-execution. Do people do things like that?
01:36:21 -!- Remavas[AFK] has changed nick to Remavas.
01:48:13 -!- Remavas has quit (Quit: Leaving).
01:51:14 <b_jonas> shachaf: either it just returns an error telling how much memory it needs, like snprintf, or it calls an allocator callback
01:51:40 <b_jonas> oh, you're asking about coroutine
01:52:11 -!- b_jonas has quit (Quit: leaving).
02:23:26 -!- tromp has joined.
02:27:33 -!- tromp has quit (Ping timeout: 245 seconds).
03:10:18 -!- xkapastel has quit (Quit: Connection closed for inactivity).
03:13:04 -!- tromp has joined.
03:15:38 <imode> a generalized version of finite automata would have transitions labeled with try/assett statements.
03:16:17 <shachaf> that sounds like a kind of scow generalization tdnh
03:17:17 -!- tromp has quit (Ping timeout: 246 seconds).
03:18:32 <imode> lemme elaborate: any given entry for a state table would look like `in <state> if <condition/action> then <assertion/action> and go to <state>`
03:18:59 <imode> I actually think someone's come up with that... abstract state machines or something.
03:27:51 -!- biscayne has joined.
03:34:42 -!- biscayne has left.
03:38:23 <esowiki> [[Bitwise Trance]] https://esolangs.org/w/index.php?diff=59789&oldid=59788 * Zzo38 * (-9)
03:49:40 <zzo38> I thought of one chess variant can be Thue-Morse chess, similar to Marseillais chess but you don't always get a extra turn.
03:49:49 <zzo38> (I don't know how well it is work)
03:50:30 <zzo38> Did you play this kind of chess?
04:12:44 <esowiki> [[Deadfish]] https://esolangs.org/w/index.php?diff=59790&oldid=59751 * Zzo38 * (-6) Colon include syntax in glasm
04:23:28 -!- FreeFull has quit.
04:49:11 <oerjan> https://esolangs.org/wiki/Vague <-- i think Cortex may be parodying certain other users...
04:50:15 <shachaf> oerjan: oh man, this is tg
05:00:56 -!- tromp has joined.
05:05:28 -!- tromp has quit (Ping timeout: 245 seconds).
05:09:27 <esowiki> [[Joke language list]] M https://esolangs.org/w/index.php?diff=59791&oldid=59782 * Oerjan * (+0) abcelmrs
05:16:53 <esowiki> [[Hurgusburgus]] M https://esolangs.org/w/index.php?diff=59792&oldid=58667 * BradensEsolangs * (-197) It's really a deque, I will continue tomorrow, don't touch
05:44:44 -!- ashirase_ has joined.
05:49:08 <shachaf> int-e: Watching the video now. Compared to this std::future lambda code, sure, I can see that coroutines would be faster.
05:49:31 <shachaf> Oh, he's writing it as a state machine, never mind.
05:55:43 -!- tromp has joined.
06:00:05 -!- tromp has quit (Ping timeout: 244 seconds).
06:20:08 <shachaf> int-e: I bet if you were comparing to C code rather than C++ code it would go the other way.
06:21:29 -!- oerjan has quit (Quit: Nite).
07:22:14 -!- tromp has joined.
07:26:36 -!- tromp has quit (Ping timeout: 250 seconds).
07:30:38 -!- liuqingyao has joined.
07:36:19 -!- liuqingyao has quit.
08:05:54 -!- tromp has joined.
09:18:24 -!- heroux has quit (Ping timeout: 250 seconds).
09:19:13 -!- heroux has joined.
09:23:01 -!- tromp has quit (Remote host closed the connection).
09:40:50 -!- arseniiv has joined.
09:43:56 -!- tromp has joined.
09:48:34 -!- Arsal has joined.
10:02:05 -!- Arsal1 has joined.
10:04:37 -!- ashirase_ has quit (Ping timeout: 268 seconds).
10:05:28 -!- Arsal has quit (Ping timeout: 245 seconds).
10:13:27 -!- ashirase has joined.
10:23:56 -!- Arsal1 has quit (Quit: Leaving).
10:47:34 -!- AnotherTest has joined.
10:49:42 <int-e> shachaf: I'll make no bets. What I see is a potential to do better lifetime analysis of variables when starting out with coroutines (if you loop over { A; yield x; B; yield y; } then you know exactly which variables need to be preserved over the course of the first and second yield respectively. A C compiler would have to basically recover the coroutines to do that. That is, given a state...
10:49:48 <int-e> ...machine, it has to figure out that after the basic block A, it will never reach A again without first reaching B. That's doable in theory, sure, but I doubt it's done.
11:16:36 -!- b_jonas has joined.
11:19:44 -!- imode has quit (Ping timeout: 250 seconds).
11:25:00 <b_jonas> zzo38: I still think that any version that adds extra turns without serious limitations to chess probably makes it less interesting. In fact, the creators of chess knew this, yet wanted to speed up the early game,
11:25:38 <b_jonas> so they didn't just add unlimited extra turns, but a restricted variant where you can move the same pawn forward twice from the starting position.
11:26:45 <b_jonas> The problems include that pieces often attack too much of the board if you can take two moves with them; and that if you have two moves and the opponent then has one, then it's very easy to set up a double attack that the opponent can't defend.
12:47:38 -!- FreeFull has joined.
12:51:58 <esowiki> [[Talk:Bitwise Trance]] N https://esolangs.org/w/index.php?oldid=59793 * Plokmijnuhby * (+709) Created page with "== Turing completeness == I'm not sure this really is a Turing complete language. Sure, it works fine as an FSM, but you run into problems when you start storing data. You wil..."
13:00:57 <esowiki> [[Bitwise Trance]] https://esolangs.org/w/index.php?diff=59794&oldid=59789 * Plokmijnuhby * (+109) /* Empty program */
13:04:10 -!- Sgeo__ has quit (Read error: Connection reset by peer).
13:04:36 -!- Sgeo__ has joined.
13:12:05 <esowiki> [[Talk:Bitwise Trance]] https://esolangs.org/w/index.php?diff=59795&oldid=59793 * Plokmijnuhby * (+183) /* Turing completeness */
13:12:42 -!- Lord_of_Life has joined.
13:22:42 -!- Essadon has joined.
14:42:56 -!- xkapastel has joined.
15:11:57 <esowiki> [[Talk:Bitwise Trance]] https://esolangs.org/w/index.php?diff=59796&oldid=59795 * Ais523 * (+1610) bignum arithmetic seems impossible to directly implement; however you could probably get a program to copy itself in memory and expand the addresses in the process, despite not being able to address things much larger than itself
16:03:40 <b_jonas> In the scifi future, when people won't have fridges and freezers that cool food, but will instead simply have a stasis box that sends food forwards in time to the next time the door is opened,
16:03:45 <b_jonas> will ice cubes in drinks turn from something ordinary that people make at home to something you only have in restaurants and bars?
16:04:36 <b_jonas> Or will people once again buy ice (or get it delivered to them in some futuristic way, whatever) and put it into the stasis box so it doesn't melt?
16:22:10 -!- oerjan has joined.
16:33:55 <esowiki> [[Hurgusburgus]] https://esolangs.org/w/index.php?diff=59797&oldid=59792 * BradensEsolangs * (-14) Done
17:07:48 <zzo38> Maybe people buying ice cubes might be less common then but some people might still have a use for it
17:12:41 -!- xkapastel has quit (Quit: Connection closed for inactivity).
17:37:16 <zzo38> You could certainly add restrictions into a chess variant that adds extra turns, and there are different ways to add how many extra turns
17:38:36 <b_jonas> maybe extra turns are overpowered in every well-designed multiplayer tabletop game, because if they weren't, then it would have been designed with more moves allowed per turn to make it more fluid
17:47:41 * oerjan wanted to use Esolang:Sandbox, and suddenly realizes it is not linked from any menus
17:52:17 <zzo38> You can also just to enter the name directly (or add it to some menu if you prefer that)
18:00:31 <b_jonas> I was wondering if I should modify the *list commands to know which strips have been listed, and refuse to list a strip again if it's been listed already
18:01:12 <shachaf> https://twitter.com/CreeepyJoe/status/1094656141173305344
18:01:59 <shachaf> int-e: Compilers already do the thing you're describing, don't they?
18:02:23 <shachaf> Maybe not for coroutines but for regular stack usage.
18:03:08 <b_jonas> so I'd change olist to do like echo -n "http://www.giantitp.com/comics/oots$1.html"; if ! test "$1" || ! grep -qxFe "$1" var/list-ids/olist; then echo -n ": "; tail -n+3 "$0" ; else echo " was already listed"; exit 1; fi
18:03:24 <b_jonas> except I'd test the shell script and fix all the errors
18:03:39 <b_jonas> oh right, it also has to say echo "$1" > var/list-ids/olist somewhere
18:04:09 <b_jonas> so it would like save the strip numbers to a file in the version control, and not ping people unless the strip is new
18:04:26 <b_jonas> that way I wouldn't have to check the channel logs to tell if a strip has already been listed
18:04:32 <b_jonas> this applies not only to olist, but also pbflist
18:04:56 <b_jonas> what does my honorable and learned friend fungot think about that idea?
18:04:56 <fungot> b_jonas: this has not been very good, and i am? with putin! the european union at the time that is not without a cost, and the fact of the matter is of course is the best security that the nation is the party of not planning. may i, in the nicest.
18:07:10 <HackEso> :#,_@ \ a.out \ bin \ canary \ emoticons \ esobible \ etc \ evil \ factor \ good \ hw \ ibin \ interps \ izash.c \ karma \ le \ lib \ misle \ paste \ ply-3.8 \ quines \ quinor \ quotes \ share \ src \ test2 \ testfile \ tmflry \ tmp \ wisdom
18:07:51 <shachaf> I don't like a commit on every list
18:08:07 <shachaf> Except, y'know, `list, where it's unavoidable
18:09:59 <fizzie> Maybe like that but keep the state in unversioned storage.
18:10:23 -!- oerjan has quit (Quit: Later).
18:12:55 <shachaf> I've considered doing that before.
18:14:09 <b_jonas> shachaf: it could be on just certain lists
18:14:24 <b_jonas> and only on successful ones with an argument
18:14:32 <b_jonas> no need to commit for a failed or a no-arg one
18:14:42 <b_jonas> that would mean a three-way if but so what
18:15:49 <b_jonas> fizzie: how does unversioned state work these days? is it just persistent, but doesn't get reverted when the bot redoes a stateful command?
18:16:08 <b_jonas> and lost whenever hackego is migrated to a new owner?
18:16:44 <zzo38> Other possibility, using Netsubscribe, storing the state by adding objects into a Netsubscribe database; if the object ID is telling what is being notified then you can easily check for duplicates
18:16:49 <b_jonas> do we have a list that's triggered whenever the previous host or maintainer of hackego gives up and the next one reincarnates it from a backup with a slightly different name?
18:17:05 <b_jonas> zzo38: um, how would you put that in hackeso?
18:18:05 <zzo38> b_jonas: I don't think hackeso has that capability, although it would be possible to use with IRC.
18:18:32 <zzo38> But about hackeso, if you need to copy any unversioned files then I suppose you can do so before moving it
18:18:44 <zzo38> (if you have enough advance notice)
18:18:56 <fizzie> b_jonas: It's just a directory. It doesn't participate in the redo in any special way (so "mv" out from it is unsafe), and will be lost if you have to migrate without access to the previous instance.
18:20:23 -!- imode has joined.
18:24:07 <fizzie> Normally you could maintain independent backups in "wget -m" style (in parallel with cloning https://hack.esolangs.org/repo) but I had to turn off nginx "autoindex" option to avoid an information leak -- there's no way to turn off following symlinks for the generated index page, so it could be used to get sizes of files outside the directory.
18:34:04 <b_jonas> fizzie: but wouldn't that mean that if I tried to store this status there, and the *list command is re-ran, then it would falsely assume that the strip has been listed already, and we'd lose pings?
18:34:46 <b_jonas> fizzie: in theory, the bot could have a directory that is reverted when a command is redone, but that isn't version-controlled. I don't know if we'd want that though.
18:35:20 <b_jonas> we might abuse it, in exactly the ways that the version repo is supposed to prevent
18:36:02 <b_jonas> fizzie: if I put a file in hgignore, would it also behave just like a file in /tmp ?
18:38:45 <b_jonas> fizzie: also, if someone, uh, "accidentally" moved everything from /hackenv to /tmp in one command, then moved everything back but also set everything to be hgignored in the next command, in order to break version control, how quickly would people notice that?
18:38:58 <b_jonas> if, say, someone did that in private message
18:45:33 -!- pikhq has quit (Ping timeout: 252 seconds).
18:46:16 -!- xkapastel has joined.
18:48:14 <esowiki> [[Fractran]] https://esolangs.org/w/index.php?diff=59798&oldid=57538 * Oerjan * (+1324) Something I thought of when pondering [[Echo Tag]]: Squeezing fraction size
18:54:59 <fizzie> b_jonas: In the normal case a *list command wouldn't ever re-run, because the only modifications it would do would be in tmp/, so there would be nothing to commit. There might be some race conditions though; with concurrent commands you might indeed lose some pings.
18:55:05 <fizzie> b_jonas: And .hgignore is read-only now. Or, rather, automatically reverted to its pristine state right before any commit, since it couldn't really be made read-only, since it's not a directory.
18:57:16 <fizzie> (I think I was looking for an option to disable .hgignore and instead configure tmp/ in .hg/hgrc instead, but didn't find one.)
18:58:12 <fizzie> (Also the non-versioned persistent storage is tmp/ aka /hackenv/tmp/, plain /tmp is not persistent across commands.)
18:59:18 -!- pikhq has joined.
19:05:04 <b_jonas> it's automatically reverted? nice
19:05:28 <b_jonas> oh, hg doesn't have that? doesn't it have a way to, like, tell what the name of that file is? Istr git had some such config
19:06:22 <fizzie> It has a way to set up additional ignore files.
19:06:42 <fizzie> From the documentation, it didn't seem like there was a way to disable the default .hgignore though.
19:06:47 <fizzie> Didn't actually try this.
19:07:24 <b_jonas> hackeso is where I used it the most, plus I've used it to clone a few other repos from the internet where people distribute some files only that way
19:07:54 <fizzie> Under the [ui] section, there's a config key 'ignore': "A file to read per-user ignore patterns from. This file should be in the same format as a repository-wide .hgignore file. Filenames are relative to the repository root. This option supports hook syntax, so if you want to specify multiple ignore files, you can do so by setting something like ignore.other = ~/.hgignore2."
19:08:13 <fizzie> The "as a repository-wide .hgignore file" sounded like it meant that's always there.
19:08:46 <fizzie> Although it's possible setting ui.ignore in the per-repository .hgrc would actually control that.
19:08:51 <b_jonas> fizzie: but does hg at least not allow .hgignore files in any directory?
19:09:00 <b_jonas> only at the repo top, right?
19:09:47 <fizzie> Yes, only at the repository root. If you want to put a .hgignore in a subdirectory, the documentation recommends "subinclude"ing it in the root .hgignore.
19:10:33 <fizzie> Still, reverting the .hgignore file is a bit messy, it needs to manually remove it first if someone replaces it with a directory tree.
19:10:35 <b_jonas> makes sense, I guess. that you can put one anywhere is mostly useful for repos where you often do partial checkouts, eg. in cvs and svn
19:11:31 <b_jonas> yeah, recursively (chmod then remove)
19:13:57 <b_jonas> I wonder what happened if someone made tmp a symlink to .
19:15:06 <fizzie> (That kind of questions are exactly why we can't have nice things.)
19:15:29 <b_jonas> I don't think it would do anything really
19:15:34 <b_jonas> hg wouldn't even notice where it points
19:17:48 <b_jonas> fizzie: I know, I've ran bots too, but I think me just asking won't make it worse
19:24:47 <fizzie> FWIW, it's still on the TODO list (though not up top) to allow (whitelisted, proxied) HTTP requests out of HackEso. It was possible at HackEgo at some point, though not for the last years.
19:26:38 <zzo38> You may wish to later add other protocols too, although that would also need whitelisted too.
19:29:49 <b_jonas> fizzie: is hackeso intended to be a bot strictly for this channel, or is it on the todo list to allow it to join other channels where it's invited?
19:31:21 <fizzie> I don't know. It's pretty channel-agnostic, I know HackEgo was on more than one channel.
19:31:42 <fizzie> Feels like it should be only on channels I'm on, though, just to keep an eye on it.
19:32:00 <fizzie> And of course the repo and such are under the .esolangs.org domain.
19:32:13 <fizzie> So the answer is probably "don't know".
19:32:42 <b_jonas> hmm, I guess technically I could just make a proxy bot that forwards between a channel and HackEso private message both ways
19:49:28 <fizzie> At one point I was writing a "z80bot", which was to be a somewhat hackbot-style thing, except using an (emulated) Z80 core, with a system call API to a versioned filesystem (read/write-style, but also to map "ROM" pages from), and internet, and whatever else wouldn't be practical to implement internally.
19:50:18 <fizzie> I think I got that about three-quarters done, with the (homegrown) Z80 emulator, the filesystem bits, and yet another IRC client library done, before abandoing it.
19:51:09 <fizzie> Don't think very many people would've spent time using it though. It's a bit bigger barrier to entry than with hackbot.
19:51:25 <kmc> that sounds fun
19:51:30 <kmc> would it run CP/M?
19:52:06 <b_jonas> fizzie: hmm, how much RAM?
19:52:26 <b_jonas> I guess it might not matter since it has access to a file system
19:52:47 <fizzie> I'm sure some porting would be necessary, since it wouldn't have any of the expected hardware by those systems.
19:52:56 <b_jonas> the hard part with these bots is always figuring out what it's allowed to do on IRC by users' commands
19:53:46 <fizzie> I think I was intending it to have just the directly addressable 64k of RAM, with the top one quarter (C000..FFFF) mappable as a ROM page from the filesystem.
19:54:20 <b_jonas> z80 has a separate IO address space, right
19:54:53 <b_jonas> fizzie: what kind of interface would it use for accessing the filesystem? a "modern" unix/dos2 one with open, close, read, write calls?
19:55:09 <fizzie> b_jonas: Yes, it has a separate I/O space, though only with 8 bits of addressing.
19:56:00 <fizzie> The syscall API had the usual read/write/seek calls, so you could access large files with (relative) ease.
19:56:24 <fizzie> (With both 16- and 32-bit variants for seek/tell.)
19:57:15 <fizzie> Well, no. I would've had some sort of quota for it.
19:57:16 -!- FreeFull has quit.
19:59:03 <b_jonas> that would hit you back ten years later when most of the utilities developed up to that time can only deal with 32-bit files, and there's no sane way to recompile them to handle 64-bit files. like what's happend in unix.
19:59:41 <b_jonas> and then again when 2038 is nearing and you still have programs storing expoch second timestamps in int32_t
19:59:47 -!- FreeFull has joined.
20:00:06 <kmc> no problem
20:00:07 <kmc> robots will kill us all before then
20:00:12 -!- shikhin has quit (Ping timeout: 250 seconds).
20:00:20 <int-e> like we need robots for doing that
20:00:43 <b_jonas> then the robots using the bot will curse you for having made such a stupid design
20:00:46 -!- shikhin has joined.
20:00:50 <zzo38> What I think I have read is that 64-bit Linux uses 64-bit timestamps, but, the filesystem does not support 64-bit timestamps.
20:01:17 <b_jonas> zzo38: yes, that's more or less the current state, but it used to be worse
20:01:35 <b_jonas> also we're mostly past the 32 bit file offset problem too
20:01:38 <int-e> shachaf: I had a quick look at the LLVM optimization passes overview at https://llvm.org/docs/Passes.html and none of that sounds like it would be able to reconstruct the coroutine basic blocks (and their sequencing, which would then enable liveness analysis on that level) from a state machine.
20:01:49 <b_jonas> but both of them caused a lot of trouble some time ago
20:02:08 <b_jonas> obviously it's never anything as simple as "unix uses ... timestamps"
20:02:17 <b_jonas> there are like a hundred different ways things on unix use timestamps
20:02:27 <zzo38> How to upgrade the filesystem to one that does support 64-bit timestamps? I do not need it right now, but maybe in eighteen years, will help
20:02:38 <int-e> ICBMs with nuclear warheads are on the doomsday menu again.
20:02:46 <kmc> they always were
20:03:04 <b_jonas> zzo38: for the file system, I'm more afraid of when the FAT timestamps run out. there still seems to be no plan to fix that, and there's no obvious way to fix it
20:03:10 <kmc> I personally do not understand how anyone who works on nuclear weapons lives with themself
20:03:12 <int-e> Oh sure but they were not advertised as such :P
20:03:19 <int-e> You'd have to ask the chef.
20:03:26 <zzo38> When do the FAT timestamps run out?
20:03:27 <b_jonas> mostly because windows 95 OSR2 was so reckless as to use up all bytes in the 32 byte directory entries, so there's no place to extend them now
20:03:47 <b_jonas> that's the mtime, but nobody cares about the other two timestamps
20:03:49 <kmc> that goes double for things like Project Pluto which were explicitly designed to kill as many civilians as possible and poison the earth
20:04:32 <b_jonas> basically it started as a 7-bit year field within a 16-bit date field, and that 7-bit year field stores the date as an integer giving a two digit year
20:04:47 <kmc> what about ntfs
20:05:19 <fizzie> Were the FAT timestamps those with the odd (or, rather, even) two-second accuracy?
20:05:39 <b_jonas> perhaps we can change all the fs drivers to treat them rolling over, so 0 would get interpreted as 2028 instead of 1900
20:05:54 <b_jonas> fizzie: yes, because the time of day is also a 16-bit field
20:06:05 <b_jonas> and there's more than 65536 seconds in a day
20:06:23 <b_jonas> so they made it 5 bits for the hour, 6 bits for the minute, 5 bits for half of the second
20:07:27 <b_jonas> optimized for speed on the 8088 obviously
20:08:54 <b_jonas> and I think it might be DOS 2 after all, not DOS 3, that started to have unix-like read/write calls after all
20:35:16 <shachaf> int-e: No, not from a state machine, I mean that optimization already exists for stack allocation in non-coroutine code.
20:35:32 <shachaf> I imagine you can do it by hand if you really cared, though, instead of using a struct.
20:35:43 <kmc> how did file IO work before that
20:36:48 <int-e> shachaf: Yes that exists but I'm not interested in that. I'm interested in a mechanism that would help a compiler starting from coroutines compared to a compiler that is facing a manually crafted corresponding state machine.
20:37:01 <zzo38> I think old DOS uses file control blocks for file I/O
20:37:52 <shachaf> I mean, I think you can still craft a state machine manually that would be as good.
20:38:55 <shachaf> Each state could have its own memory layout and you'd do the liveness analysis and so on yourself. Or something.
20:40:10 <b_jonas> kmc: DOS1 had inherited the kind of IO from CP/M where (1) there's no close, the file descriptor is a fixed size structure, and more importantly, (2) read and write work in fixed size blocks, you can't choose how many bytes to read and write, (3) file size is tracked by the fs in block granularity, not byte granularity
20:40:43 <b_jonas> and that's on a floppy disk, so it's less strange than the tape IO, which has variable sized blocks
20:41:05 <b_jonas> it can have fixed sized blocks on tape too
20:41:30 <b_jonas> oh, and there were no directories, or rather, only one per drive
20:42:26 <b_jonas> that's why text files in DOS used to have an extra "EOF" byte at the end, so they can be read by very old programs that use the CP/M calls and wouldn't know how many characters there are in the last sector
20:42:33 <kmc> I had a computer that ran what I think was an old version of DOS, or similar
20:42:37 <kmc> the TRS-80 Model 100
20:42:43 <kmc> (which has nothing to do with the other trash-80s)
20:42:48 <kmc> such a cool machine
20:45:26 <kmc> a laptop from 1983 that's *actually portable*, all solid state storage, indestructable, instant boot, 16 hours battery life
20:45:55 <b_jonas> with the unix-like interface, DOS introduced the unix idea of how programs can use the console device with the same read/write calls as you use for disk files
20:46:16 <kmc> and a good keyboard
20:46:35 <kmc> of course, in terms of CPU and RAM it was quite underpowered compared to desktops of the day and the luggables
20:46:46 <kmc> and you couldn't run real business software
20:46:59 <kmc> but still very good at certain niches, such as traveling journalists
20:47:16 <b_jonas> why would a traveling journalist need a computer?
20:47:43 <kmc> you could write text with the built in word processor and then send it back to the home office at 300 baud, using an acoustic coupler in your hotel room :P
20:49:16 <int-e> . o O ( better bring a cart? :) )
20:49:19 <kmc> it had a basic BASIC too, you could do cool things like scripting the terminal program to log you in automatically, etc
20:49:42 <kmc> also I guess they envisioned it for portable POS use b/c it has a barcode reader, you could make your own POS software in BASIC i suppose
20:50:01 <kmc> I'm not sure if it had expansion ROMs for other programs
20:50:43 <kmc> iirc it did have PEEK and POKE, so you could probably have additional native code programs in RAM, and load them from the tape port with a BASIC stub
20:51:04 <kmc> however the RAM is limited and is also the only built-in 'nonvolatile' storage (via backup battery)
20:51:17 <kmc> that's why it had instant on, like a graphing calculator
20:51:57 <kmc> it was already obsolete by the time I was born, but I had a hand-me-down and got many hours of fun out of it
20:52:02 <kmc> I can still remember how the leather case smelled
20:52:14 <kmc> funny how smells stay with you for life.
20:52:47 <kmc> anyway, I loaded / saved programs into the Windows 95 sound recorder program, using the tape cable
20:53:35 <b_jonas> didn't you have a proper casette recorder?
20:53:41 <kmc> well, less wasteful than a real casette recorder
20:53:47 <kmc> although that'd be more authentic
20:53:54 <kmc> i mean, i didn't have to buy tapes :P
20:54:00 <kmc> i might have been able to do it on my dad's boombox
20:54:04 <b_jonas> it stores the wave forms uncompressed
20:54:08 <kmc> using a bunch of transistors you have sitting around anyway is not really waste
20:54:09 <b_jonas> you can't store much on a disk that way
20:54:11 <kmc> that is true
20:54:20 <kmc> however i didn't have that many programs
20:54:20 <b_jonas> a few casettes would store more
20:54:24 <kmc> and each one was < 30 seconds of audio
20:54:30 <kmc> also I bet you could dither them to 8 bits
20:54:32 <kmc> didn't try tho
20:54:38 <kmc> anyway even back then I had a 1 GB hard drive
20:54:57 <kmc> to get the cable, my dad took me to radio shack -- this would have been mid to late 90s -- and they were shocked that someone was there to buy an accessory for a 15 year old computer, and even more shocked that they actually had one in the back room, in decaying packaging
20:54:59 <b_jonas> sure, but even with one gigabyte of hard drive
20:55:03 <zzo38> Do you have a program that can convert the sound files to/from a more compact recording of the programs?
20:55:06 <int-e> . o O ( did it come on a truck? )
20:55:06 <b_jonas> that's not more than a few recordable tapes
20:55:12 <kmc> zzo38: no, but it would probably be pretty easy to make
20:55:13 <b_jonas> I mean, you can only record an hour or two on that
20:55:23 <b_jonas> I had more recordable casettes than that when I was a child
20:55:35 <int-e> oh mid to late 90s... fine
20:56:18 <kmc> but i did much more BASIC programming on TI calcs
20:56:19 <int-e> IIRC around that time HDD sizes doubled every two years.
20:56:40 <kmc> because I could easily take it to school, and mess around in math class while pretending to work on the material I'd already finished :P
20:56:43 <kmc> int-e: I'd believe it
20:56:51 <kmc> the TI calculators were also more capable in many ways
21:05:47 -!- xkapastel has quit (Quit: Connection closed for inactivity).
21:06:19 -!- xkapastel has joined.
21:35:16 -!- ashirase has quit (Remote host closed the connection).
21:55:26 -!- arseniiv has quit (Ping timeout: 240 seconds).
22:04:33 -!- Remavas has joined.
22:06:08 -!- Remavas has changed nick to Remavas[AFK].
22:28:33 <b_jonas> `perl -eopen$F,">tmp/perm10"; @a=0..9;for$s(1..3628800){ print$F"@a\n";$k=$s;$m=2;$k/=$m++until$k%$m;@a[0,$m-1]=@a[$m-1,0]; }; warn "done"
22:28:34 <HackEso> String found where operator expected at -e line 1, near "$F"@a\n"" \ (Missing operator before "@a\n"?) \ File size limit exceeded
22:28:40 <b_jonas> `perl -eopen$F,">tmp/perm10"; @a=0..9;for$s(1..3628800){ print$F "@a\n";$k=$s;$m=2;$k/=$m++until$k%$m;@a[0,$m-1]=@a[$m-1,0]; }; warn "done"
22:28:55 <b_jonas> `perl -eopen$F,">tmp/perm10"; @a=0..9;for$s(1..3628800){ print$F join("",@a),"\n";$k=$s;$m=2;$k/=$m++until$k%$m;@a[0,$m-1]=@a[$m-1,0]; }; warn "done"
22:29:38 <b_jonas> is that ten megabytes or five megabytes?
22:29:56 <b_jonas> in any case, it's too small for this
22:31:14 <b_jonas> TAOCP 7.2.1 says "No sensible person would want to make a list of the 10! = 3,628,800 permutations of {0,1,2,3,4,5,6,7,8,9} by printing them out on thousands of sheets of paper, nor even by writing them all in a computer file."
22:31:31 <b_jonas> that sounds like the sort of thing #esoteric would want to do then
22:31:51 <b_jonas> but the 5 megabyte limit makes it impossible
22:33:31 <int-e> > length $ permutations [0..9] >>= (++ "\n") . (>>= show)
22:33:45 <int-e> > length $ permutations [1..9] >>= (++ "\n") . (>>= show)
22:33:57 <b_jonas> `perl -eopen$F,"|wc"; @a=0..9;for$s(1..3628800){ print$F "@a\n";$k=$s;$m=2;$k/=$m++until$k%$m;@a[0,$m-1]=@a[$m-1,0]; }; warn "done"
22:34:04 <HackEso> done at -e line 1. \ 3628800 36288000 72576000
22:34:20 <b_jonas> `perl -eopen$F,"|wc"; @a=0..9;for$s(1..3628800){ print$F join("",@a),"\n";$k=$s;$m=2;$k/=$m++until$k%$m;@a[0,$m-1]=@a[$m-1,0]; }; warn "done"
22:34:24 <HackEso> done at -e line 1. \ 3628800 3628800 39916800
22:35:06 <int-e> you should also consider the age of TAoCP.
22:35:37 <b_jonas> and it doesn't say that it can't be done, it says it's not worth
22:36:13 <b_jonas> or at least that it's not what you usually want when you're asking for generating all permutations
22:36:17 <int-e> it does make for a fun compression benchmark
22:36:26 <b_jonas> vol 4 handles some pretty big tasks
22:39:19 <int-e> gzip -9: 1620145, bzip2 -9: 1150986, xz -9: 48068 ... wow?!
22:39:45 <b_jonas> int-e: which order of permutations is that? the one I gave, or the one you gave?
22:40:08 <int-e> with spaces and newlines
22:40:46 <b_jonas> `perl -e@a=0..5;for$s(1..999){ print join("",@a),"\n";$k=$s;$m=2;$k/=$m++until$k%$m;@a[0,$m-1]=@a[$m-1,0]; };
22:40:47 <HackEso> 012345 \ 102345 \ 201345 \ 021345 \ 120345 \ 210345 \ 310245 \ 130245 \ 031245 \ 301245 \ 103245 \ 013245 \ 213045 \ 123045 \ 321045 \ 231045 \ 132045 \ 312045 \ 012345 \ 102345 \ 201345 \ 021345 \ 120345 \ 210345 \ 410325 \ 140325 \ 041325 \ 401325 \ 104325 \ 014325 \ 314025 \ 134025 \ 431025 \ 341025 \ 143025 \ 413025 \ 013425 \ 103425 \ 301425 \ 031425 \ 130425 \ 310425 \ 410325 \ 140325 \ 041325 \ 401325 \ 104325 \ 014325 \ 214305 \ 124305 \ 421305 \ 2
22:41:12 <b_jonas> `perl -e@a=0..4;for$s(1..120){ print join("",@a),"\n";$k=$s;$m=2;$k/=$m++until$k%$m;@a[0,$m-1]=@a[$m-1,0]; };
22:41:13 <HackEso> 01234 \ 10234 \ 20134 \ 02134 \ 12034 \ 21034 \ 31024 \ 13024 \ 03124 \ 30124 \ 10324 \ 01324 \ 21304 \ 12304 \ 32104 \ 23104 \ 13204 \ 31204 \ 01234 \ 10234 \ 20134 \ 02134 \ 12034 \ 21034 \ 41032 \ 14032 \ 04132 \ 40132 \ 10432 \ 01432 \ 31402 \ 13402 \ 43102 \ 34102 \ 14302 \ 41302 \ 01342 \ 10342 \ 30142 \ 03142 \ 13042 \ 31042 \ 41032 \ 14032 \ 04132 \ 40132 \ 10432 \ 01432 \ 21430 \ 12430 \ 42130 \ 24130 \ 14230 \ 41230 \ 31240 \ 13240 \ 23140 \ 3214
22:41:28 <b_jonas> `perl -e@a=0..4;for$s(1..120){ print join("",@a)," ";$k=$s;$m=2;$k/=$m++until$k%$m;@a[0,$m-1]=@a[$m-1,0]; };
22:41:29 <HackEso> 01234 10234 20134 02134 12034 21034 31024 13024 03124 30124 10324 01324 21304 12304 32104 23104 13204 31204 01234 10234 20134 02134 12034 21034 41032 14032 04132 40132 10432 01432 31402 13402 43102 34102 14302 41302 01342 10342 30142 03142 13042 31042 41032 14032 04132 40132 10432 01432 21430 12430 42130 24130 14230 41230 31240 13240 23140 32140 12340 21340 41320 14320 34120 43120 13420 31420 21430 12430 42130 24130 14230 41230 01234 10234 20134 02134 1203
22:41:46 <b_jonas> that's not even all permutations
22:42:36 <int-e> right I was going to check that... and that does explain the good compression, I guess.
22:44:32 <int-e> for the Haskell thing (newline, no spaces), gzip -9: 7913058; bzip2 -9: 9620381; xz -9: 1562180.
22:46:30 <int-e> and with spaces: gzip -9: 9525275; bzip2 -9: 9846341; xz -9: 2242728.
22:46:48 <b_jonas> how about with (7z a -mx=9 -sia kts-Ae6seFQj.7z; cat kts-Ae6seFQj.7z) ?
22:47:21 <b_jonas> (7z won't compress to a pipe, so I'm using a temporary file here)
22:47:47 <b_jonas> oh wait, you're saying gzip -9 rather than gzip -c9 so I don't have to cat it
22:48:11 <int-e> I'm piping into it.
22:48:34 <b_jonas> piping into it is fine, it can take the uncompressed input in a pipe
22:48:46 <b_jonas> it just can't put or take the compressed file from a pipie
22:49:05 <b_jonas> so for compressing, it can read from a pipe, for decompressing it can write to a pipe
22:49:14 <int-e> Archive size: 1759018 bytes (1718 KiB)
22:49:33 <b_jonas> ha! so it does sometimes win over xz
22:56:34 -!- tromp has quit (Remote host closed the connection).
23:09:14 <shachaf> int-e: I wonder whether there's a test program to run benchmarks with.
23:15:56 -!- AnotherTest has quit (Ping timeout: 240 seconds).
23:27:16 -!- tromp has joined.
23:29:46 -!- Essadon has quit (Quit: Qutting).
23:30:42 <fizzie> I think it's 10 megabytes; bash ulimit -f is in 1024 byte units, except when in Posix mode.
23:30:46 <fizzie> `` ulimit -f; sh -c "ulimit -f"
23:32:04 -!- tromp has quit (Ping timeout: 250 seconds).
23:32:40 <fizzie> Actually, what's sh there?
23:32:43 <HackEso> lrwxrwxrwx 1 0 0 4 Jan 24 2017 /bin/sh -> dash
23:35:36 <HackEso> ELF............>.....7......@.................@.8..@.........@.......@.......@..................................8......8......8......................................................................... ..................!.....!...........>........ ...........h......h!.....h!................................T......T......T......D.......D..............Ptd...f......f......f.........................Q
23:36:04 -!- Remavas[AFK] has quit (Quit: Leaving).
23:38:00 <HackEso> Cats are cool, but should be illegal.
23:38:11 <kmc> i disagree
23:38:13 <HackEso> 1/2:precision//78.75211317% of the time precision is totally overrated. \ gene ray//Dr Gene Ray is the Greatest Philosopher, and is the Greatest Mathematician. Cubic Harmonics. Only Cubic Harmonics can save humanity. Cubic Harmonics will pacify all religions. 96-hour Cubic Day debunks 1-day unnatural god. 96-hour day willdisprove disunity god. Academians are teaching - pseudocience. Worshipping a Word God will destroy the USA. \ web access//Sorry, Ha
23:38:19 <HackEso> 2/2:ckEgo's sandbox currently has no web access. However, see `? `fetch \ type system//type system = kitten \ bugbear//A bugbear is a teddy bear that you can explain your bugs to.
23:38:56 <HackEso> `fetch [<output-file>] <URL> downloads files, and is the only web access currently available in HackEgo. It is a special builtin that cannot be called from other commands. See also `edit.
23:41:12 <HackEso> `! \ `# \ `fetch \ guarantee \ hackego \ hackeso \ `help \ `hoag \ list \ med \ print_args_or_input \ ruddy \ `run \ source \ test \ tmp \ web access \ zarutian
23:42:05 <HackEso> You can trust Zarutian. He fixes, as an electronics technician, banal mistakes of electronics engineers. Rather cy(ph|b)erpunkish in outlook regarding the 'Net. Knows more about ocaps than you can imagine. Possesses an Icelandic unnerver that ejects freezingly hot lava out of its business end. Bears an 'Authentic fakes provider' seal from the guild of Realers. He is also known for making rather long HackEgo wisdom entries. Take for instance this entry. It
23:42:41 <int-e> . o O ( `pwste zarutian )
23:42:51 <int-e> `paste wisdom/zarutian
23:42:52 <HackEso> https://hack.esolangs.org/repo/file/tip/wisdom/zarutian
23:43:02 <HackEso> 2/2: It has a whole subentry just on Icelandic unnerver. Even though the Icelandic unnerver has its own.
23:43:20 <int-e> I also can't remember the proper repository URL command
23:43:38 <fizzie> I was just wondering if there was a `wrl.
23:44:52 <HackEso> come on, you can type seven characters
23:45:24 <HackEso> 9814:2016-12-02 <shachäf> mkx bin/hwrl//echo \'come on, you can type seven characters\'
23:45:46 <int-e> what a horrible, opinionated character
23:46:30 * int-e also wonders about the difference between `url and `hurl
23:46:37 <shachaf> I don't remember that. Maybe it was an impostor.
23:46:40 <fizzie> Also horrible: there are entirely independent scripts bin/url and bin/hurl, where the only difference is that only the former supports tmp.
23:46:51 <HackEso> #!/usr/bin/env python \ import sys, os.path, re, urllib \ if len(sys.argv) <= 1: \ print "https://hack.esolangs.org/repo/" \ else: \ f = os.path.abspath(sys.argv[1]) \ f = re.sub(r"^/+hackenv/", "", f) \ if re.match(r"/|(?:\.hg|tmp)(?:/|$)",f): \ sys.exit("File is outside web-viewable filesystem repository.") \ else: \ print ("https://hack.esolangs.org/repo/log/tip/" + \ urllib.quote(f))
23:47:00 <HackEso> 11469:2018-04-08 <fizzïe> sled bin/hurl//s,hackego.esolangs.org/fshg,hack.esolangs.org/repo,g;s,/index\\.cgi,, \ 10395:2017-03-11 <oerjän> sled bin/hurl//s,http,https,g \ 10316:2017-02-18 <fizzïe> sled bin/hurl//s,codu.org/projects/hackbot,hackego.esolangs.org, \ 9142:2016-10-02 <oerjän> ` cp bin/{,h}url; sed -i \'11s/file/log/\' bin/hurl
23:47:06 <HackEso> /srv/hackeso-code/multibot_cmds/lib/limits: line 5: exec: cblprits: not found
23:47:21 <HackEso> fizzïe oerjän fizzïe oerjän
23:47:32 <HackEso> fizzïe fizzïe oerjän fizzïe oerjän fizzïe fizzïe fizzïe oerjän oerjän oerjän oerjän oerjän oerjän oerjän oerjän fizzïe fizzïe fizzïe fizzïe oerjän oerjän oerjän oerjän oerjän oerjän nitïa
23:47:42 <fizzie> ...yeah, nobody else to blame.
23:47:57 <HackEso> https://hack.esolangs.org/repo/file/tip/bin/url
23:48:22 <fizzie> Looks like I even fixed the paths in both url and hurl 10 months ago.
23:48:31 <shachaf> So these aren't totally separate, they're almost identical.
23:49:10 <fizzie> I guess you can argue that because of the "h" in "hurl", it should only work for repository contents, while "url" is okay to support tmp as well.
23:49:30 <shachaf> Wait, these aren't independent.
23:49:34 <shachaf> One of them is for the history of a file.
23:49:58 <int-e> `mkx hwrl//hurl "wisdom/$1"
23:50:06 <fizzie> I guess that makes sense.
23:50:09 <HackEso> come on, you can type seven characters
23:50:30 <HackEso> https://hack.esolangs.org/repo/log/tip/wisdom/zarutian
23:50:39 <int-e> `mkx bin/wrl//url "wisdom/$1"
23:50:46 <HackEso> https://hack.esolangs.org/repo/file/tip/wisdom/zarutian
23:50:47 <shachaf> I guess hurl can't support tmp. Oh well.
23:51:03 <fizzie> Yes, it makes sense, I just didn't realize what it was for.
23:51:28 <int-e> Yeah I was puzzled by the 'h' as well. So I learned something... useless. Yay.
23:52:23 <shachaf> If you didn't know what hurl was, why were you hwrling?
23:52:39 <int-e> because I looked at /bin in the repo browser
23:53:02 <HackEso> https://hack.esolangs.org/repo/file/tip/bin
23:53:20 <shachaf> Why is bin so full of nonsense?
23:53:36 <int-e> Because of the people. That is, us. :P
23:53:43 <HackEso> #!/bin/bash \ sha1sum "$@" | tr a-z n-za-m
23:53:52 <HackEso> 2666:2013-04-14 <km̈c> printf \'#!/bin/bash\\nsha1sum "$@" | tr a-z n-za-m\' > bin/shachaf1sum && chmod +x bin/shachaf1sum
23:54:20 <shachaf> kmc: SMILING CAT FACE WITH HEART-SHAPED EYES
23:54:33 <int-e> `culprits bin/<command>
23:54:38 <fizzie> HackEso: binaries of the people, by the people, for the people.
23:54:40 -!- Lord_of_Life_ has joined.
23:54:50 <HackEso> echo Stop taking everything literally!
23:54:59 <shachaf> fizzie: There's still a DNS entry for hackego.esolangs.org
23:55:00 <HackEso> Runs arbitrary code in GNU/Linux. Type "`<command>", or "`run <command>" for full shell commands. "`fetch [<output-file>] <URL>" downloads files. Files saved to $PWD are persistent, and $PWD/bin is in $PATH. $PWD is a mercurial repository, "`revert <rev>" can be used to revert to a revision. See http://codu.org/projects/hackbot/fshg/
23:55:07 <shachaf> Which was confusing when I tried to hg pull a little while ago.
23:55:14 -!- Lord_of_Life has quit (Ping timeout: 246 seconds).
23:55:41 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
23:55:57 <fizzie> shachaf: I guess it doesn't look too likely the Cloud at Cost host is coming back...
23:56:03 <HackEso> Shaventions include: before/now/lastfiles, culprits, hog/{h,d}oag, le//rn, tmp/, mk/mkx, {s,p}led/sedlast, spore/spam/speek/sport/1/4/5, edit. Taneb did not invent them yet.
23:56:13 <shachaf> No one ever uses things like before/now/lastfiles
23:56:51 <shachaf> I think edit is a fizzievention by now
23:57:25 <fizzie> int-e: I think that's for ruining an error quote.
23:57:44 <HackEso> 0:2012-02-16 Initïal import.
23:57:45 <fizzie> Or something along those lines.
23:57:56 <HackEso> nitia is the inventor of all things. The BBC invented her.
23:58:43 <shachaf> Probably https://en.wikipedia.org/wiki/BBC_Nitia
23:59:26 <HackEso> OLD="wisdom/$1"; [ -z "$1" ] && OLD="$(lastfiles)"; NEW="${OLD}s"; if [ -f "$NEW" ]; then echo "«${NEW}» already exists"; exit 1; fi; mv "$OLD" "$NEW" && echo "«${OLD}» -> «${NEW}»"
23:59:35 <HackEso> 9714:2016-11-17 <oerjän> whoop ../bin/whoop \ 9713:2016-11-17 <shachäf> ` mv bin/whoop{s,} \ 9710:2016-11-17 <oerjän> ` mv bin/whoops{s,} \ 9709:2016-11-17 <oerjän> whoops \ 9708:2016-11-17 <oerjän> mkx bin/whoops//OLD="wisdom/$1"; [ -z "$1" ] && OLD="$(lastfiles)"; NEW="${OLD}s"; if [ -f "$NEW" ]; then echo "\xc2\xab${NEW}\xc2\xbb already exists"; exit 1; fi; mv "$OLD" "$NEW" && echo "\xc2\xab${OLD}\xc2\xbb -> \xc2\xab${NEW}\xc2\xbb" \ 5338:2015