00:00:45 <korvo> Redirect from #raku: https://niklas-heer.github.io/speed-comparison/ is quite interesting in terms of the tiers that seem to emerge. We can almost guess what each tier's doing.
00:09:41 <esolangs> [[Kool]] https://esolangs.org/w/index.php?diff=170468&oldid=160191 * A() * (+577)
00:10:01 <esolangs> [[Kool]] https://esolangs.org/w/index.php?diff=170469&oldid=170468 * A() * (+0)
00:10:55 <esolangs> [[Kool]] https://esolangs.org/w/index.php?diff=170470&oldid=170469 * A() * (+1)
00:12:21 <esolangs> [[Kool]] https://esolangs.org/w/index.php?diff=170471&oldid=170470 * A() * (+1) /* Xor gate */
00:12:47 <esolangs> [[Kool]] https://esolangs.org/w/index.php?diff=170472&oldid=170471 * A() * (+0)
00:27:11 <ais523> korvo: not sure "redirect" is the right word, but I'm struggling to figure out what the right word is – maybe "crosspost"
00:28:25 <ais523> it is curious to see C++ faster than C and Rust which are effectively tied – this makes me think that the program may have an optimisation that's missing in the other languages, and I would be surprised if the optimisation were tied to C++ in particular
00:30:06 <ais523> also Rust nightly being over twice as fast as non-nightly Rust is bizarre, I know Rust nightly doesn't have that big a performance improvement, so it's probably a case of the nightly version using an unstable feature and the non-nightly version not having a good workaround for it
00:30:15 <korvo> ais523: I suppose I should have said "forked from" or "tangent from". It's not a proper redirect, in the sense that the conversation didn't start here. (It's still used that way in USA court too, where it revisits a prior line of discussion.)
00:31:34 <ais523> oh, the "nightly" version is SIMD, that makes a big difference
00:32:38 <int-e> ais523: huh that's weird indeed; https://github.com/niklas-heer/speed-comparison/blob/master/src/leibniz.cpp and -.c look identical.
00:34:08 <int-e> Rust uses (2..rounds).for_each(|i| {...}) and I'm never sure how exactly and how reliably that gets transformed into a loop.
00:34:17 <ais523> the C and C++ must be being compiled with fast-math
00:34:28 <ais523> otherwise they would have the same performance as the Rust version
00:35:10 <ais523> int-e: it's equivalent to «for i in 2..rounds { … }», the version with the for loop would be more idiomaic
00:36:29 <int-e> sure, but it's up to the compiler to actually provide equal performance for those two versions
00:37:13 <int-e> I know that I've seen speedups from replacing range.for_each(|x| ... ) by for x in range { ... }
00:37:37 <ais523> int-e: I'm confused, they should be *literally* equivalent
00:38:10 <int-e> Well, no, because one naively creates a closure and calls it many times and the other doesn't.
00:38:13 <sorear> the big cluster of languages that includes "stable Rust" all have mandatory bounds checking in common, so I wonder if the difference has something to do with range optimizations
00:38:26 <ais523> hmm, apparently not: https://doc.rust-lang.org/stable/src/core/iter/traits/iterator.rs.html#818-829
00:38:47 <sorear> (actually looks at code, notices lack of array)
00:38:49 <int-e> so there's a bunch of inlining that *has* to happen before they become the same
00:38:51 <ais523> I was expecting it to just be implemented as "for x in self { (f)(x) }" but the implementation is more complicated than that
00:39:32 <sorear> kind of surprised there are language differences at all, this looks like something you'd write to stress FDIV for uops.info
00:39:35 <int-e> for i in ... also has some unfolding to do because of the iterator interface
00:40:18 <ais523> <int-e> Well, no, because one naively creates a closure and calls it many times and the other doesn't. ← Rust closures don't work like you're expecting them to, they have unique types and Rust monomorphises by default, so the only way to not inline them is to explicitly use code that tells it to not monomorphize (dyn or a cast to function pointer)
00:40:50 <ais523> sorear: the really big difference is that it's adding to a floating-point-typed accumulator and all the additions are done in sequence
00:41:32 <int-e> ais523: For C and C++, the flags appear to be {gcc,g++} leibniz.c -o leibniz -O3 -s -static -flto -march=native -mtune=native -fomit-frame-pointer -fno-signed-zeros -fno-trapping-math -fassociative-math
00:41:50 <ais523> because floating point has rounding errors, any optimisation that changes the order in which the additions occur could potentially change the result, so if you're using a language that tries to match the program's semantics exactly you can't vectorise this
00:42:35 <ais523> int-e: -fassociative-math is the main thing that makes the huge speedup legal, the no-signed-zeros and no-trapping-math are probably needed to make it work on current hardware though
00:42:41 <int-e> and for clang{,++} they add -mtune=native
00:42:58 <ais523> well gcc also has march=native and mtune=native
00:43:10 <ais523> but that isn't so useful without knowing the processor that it's being compiled on
00:43:11 <sorear> anything that N=2 unrolls the loop will remove half the adds and multiplies
00:43:25 <int-e> ais523: ah, sorry, it was obscured by a line break
00:43:52 <int-e> So I *really* don't understand why C and C++ are noticably different. Could be a code alignment thing I suppose.
00:44:39 <int-e> Anyway, these flags and more are in https://github.com/niklas-heer/speed-comparison/blob/master/Earthfile
00:44:55 <ais523> code alignment is so annoying because it has significant effects but it is very hard to tell what they are in order to optimise for them
00:46:16 <int-e> "the big optimization" is vectorization, I presume
00:46:46 <ais523> the "non-nightly" Rust should be very close to max speed for a nonvectorised version
00:46:51 <korvo> As a general hint, it looks like this repo tries to separate SIMD and non-SIMD entries; if a language shows up twice and there's no other plausible difference, it's probably SIMD.
00:47:03 <ais523> unless it isn't being unrolled properly, but LLVM likes to unroll by 2 or 4
00:48:04 <ais523> the version number of Perl is stated as just "5" which seems unlikely to me, Perl 5.0 was obsolete decades ago
00:48:20 <ais523> it's probably forgotten to specify the minor version
00:50:07 <ais523> I'm vaguely wondering how INTERCAL would do, but given that it would be a soft-float implementation, it would likely be considerably slower than everything else on the chart
00:50:49 <sorear> no faith in your idiom recognizer?
00:51:36 <ais523> sorear: it's a pretty good idiom recognizer but it only optimises within an expression
00:51:53 <ais523> and even integer additions in INTERCAL are almost always done with loops
00:52:25 <sorear> even llvm does loop idioms these days
00:52:28 <ais523> the idiomatic way to do float calculations in INTERCAL would be to link in flonck, which definitely can't do the operations in a single expression
00:52:39 <ais523> C-INTERCAL doesn't optimise across statements
00:53:04 <ais523> you would need a lot of special cases for things like abstain and forget and come from…
00:54:17 <korvo> ais523: The Raku folks would appreciate it if you added a new slowest language. I was thinking of adding a Monte version to see how bad it is.
00:54:39 <ais523> I haven't significantly worked on C-INTERCAL for a while, but one of the things I wanted to add (and made some progress towards) was a constraint solver
00:54:58 <korvo> There are also languages which could be very funny to add, like awk.
00:55:06 <int-e> ais523: it feeds the output of `perl -v` into this: https://github.com/niklas-heer/speed-comparison/blob/master/scmeta/src/scmeta.cr#L32-L49
00:55:29 <ais523> so that when assigning to an expression, it would ensure that any variable that was used multiple times in the expression would be given the same value for each use
00:55:35 <ais523> (the fact that it doesn't currently do that is arguably a bug)
00:56:00 <int-e> so it finds `5` before `40` and `1` and `5.40.1`.
00:56:08 <ais523> with the constraint solver, implementing addition as a single calculate statement is probably not too difficult
00:56:35 <sorear> this seems much worse than the old shootout
00:57:05 <sorear> that at least had benchmarks testing PL features like recursion, not just "how fast is your CPU's divider and how YOLO is your fast-math impl"
00:58:15 <sorear> Actual Perl 5 needs to account for the fact that perl <= 5.005 version numbers are floats, not strings
00:58:27 <int-e> `` perl -v | head -n 2
00:58:30 <HackEso> \ This is perl 5, version 28, subversion 1 (v5.28.1) built for x86_64-linux-gnu-thread-multi
00:58:39 <ais523> right, I was trying to find a simple command that reports the Perl version number in an easily parseable way
00:59:07 <ais523> but before perl 5.6 the only programmatic access is the version number as an encoded float
00:59:35 <int-e> Somehow I doubt they'd care about supporting old Perls :-P
00:59:44 <ais523> my current Perl's $] is 5.040001 which is very hard to read if you don't know the encoding rules
01:00:11 <ais523> that's a clean way to do it on more recent Perls
01:01:22 <ais523> (although a slightly weird one, the result of $^V is a magical type that looks different based on how you use it, like $! does)
01:02:03 <int-e> lol "Add Perl version. Closes #3." (wrong kind of version; this is a variant of the leibniz program :P)
01:02:30 <ais523> `` perl -E '$!=20; say $!'
01:02:50 <sorear> arguably $^V is more of a magical type than $!
01:03:06 <sorear> $! just uses variable features to set both the string and numeric value
01:03:12 <ais523> with $! it's more that the variable itself is magical, than that the type is
01:03:24 <sorear> whereas $^V is a version object that can be assigned to other variables
01:03:48 <ais523> I have fond memories of stealing the magic from @_ in order to do something or other, but I can't remember what I was doing or why
01:04:11 <ais523> I don't think it was intended as a practical thing to do, it was part of a puzzle or codegolf or something like that
01:04:44 <sorear> most of the interesting magic variable tricks are easier to do from the C API than golfed perl itself
01:06:05 <ais523> oddly enough I've been doing something similar in Rust, stealing the magic from Display/Debug in order to call functions that need a formatter argument
01:06:29 <ais523> (I think there have been discussions about adding a non-hacky way to create a Formatter in order to be able to do that legitimately)
01:07:05 <sorear> the format-args macros are magic but I didn't think the traits were?
01:07:25 <int-e> that's the point though isn't it...
01:07:34 <ais523> the traits aren't, but they're the only things that the formatting functions are willing to speak to
01:07:45 <ais523> so you need to go via the trait to steal the magic from the macro
01:12:44 <int-e> https://doc.rust-lang.org/std/fmt/index.html#format_args covers the other half of this
01:15:09 <ais523> I'm quite familiar with format_args! weirdness because format_args! and pin! are the two stable macros that do something that logically could be expressed with normal Rust code except that they have weird lifetime/scoping effects that can't be replicatd
01:15:50 <ais523> and the details of those specific weird effects keep breaking and causing bug reports
01:16:55 <ais523> ("super let" is a good search term if you're interested – it's an old proposed name for the technique but I don't think there's a new one yet, so everyone uses the old name)
01:40:37 -!- joast has quit (Quit: Leaving.).
01:57:07 <b_jonas> ais523: IIUC format_args! does two or three separate magical things. (1) takes the non-first arguments by reference without an explicit `&` sign, (2) vararg, so if you wanted a non-macro version you'd be passing a variable-length tuple of references instead of variable number of arguments, and (3) during compile time, it parses the format string argument and typechecks the other arguments according to
01:57:13 <b_jonas> them, this may or may not be magic in that maybe current rust can do it in constexpr time, but I don't think it can yet.
01:57:43 <ais523> b_jonas: oddly it isn't format_args! magic that I wanted, but that of write!
01:57:59 <ais523> which is able to make a Formatter, something you can't otherwise do in stable Rust without using a write!-like macro
01:58:02 <b_jonas> you can certainly do (3) in runtime, but it's useful to do it in compile time for earlier detection of mistakes
01:58:33 <ais523> format_args! being a macro is fine (although (1) annoys me, it seems like the inconsistency is not worth any perceived benefit)
01:59:19 <b_jonas> I don't like format_args, but that's not because of any of these magic
02:00:30 <ais523> what are the drawbacks of C++-style print chaining?
02:00:50 <b_jonas> (1) and (2) can easily be replicated by a macro that adds the ampersands, and you can just pub both the underlying function and the convenience macro. (3) is hard but can probably be implemented by a compiler plugin macro.
02:00:51 <ais523> cout << "abc" << x << "def";, that sort of thing
02:09:43 <b_jonas> ais523: printf("(%5.2f,%5.2f)", x[0], x[1]); versus cout << fixed << setprecision(2) << "(" << setw(5) << x[0] << "," << setw(5) << x[1] << ")"; // the later hasn't even restored the format flags and precision for later
02:10:39 <ais523> b_jonas: right, I think you'd use newtypes rather than filehandle state in order to make this sort of thing less ufly
02:11:15 <ais523> cout << "(" << fixed(5,2,x[0]) << "," << fixed(5,2,x[1]) << ")";
02:15:11 <b_jonas> this kind of formatted debugging output is just so common in my code that printf-like format patterns are very useful for it. it's fine to expose a different interface too, but I want printf-like format specifications. and proper floating-point formats, which is currently missing from the rust standard library. and being able to output byte strings unchanged without them necessarily being utf-8 strings.
02:15:17 <b_jonas> and another function that formats into utf-16 output directly, but I admit this one may be a stretch.
02:21:24 <ais523> I guess from my point of view, printf is varargs but it's inherently just running separately on each argument and concatenating, so the varargs isn't actually required
02:21:57 <b_jonas> for floating-point, I want all three of %a, %e, %g formats both such that I can specify the precision (it's fine if there's an upper bound on how many digits I can requests) and such that sufficient number of digits are written that parsing the output gives the original number, and %f format with the given number of digits after the decimal point.
02:22:00 <ais523> so it's basically about how much sugar you ant to put around it
02:23:21 <b_jonas> and I insist on C printf-like format strings because I'm not going to type "{:.2f}" instead of "%.2f" all the time, and I definitely won't put up with rust format's stupidity where "{}" means %f instead of %g
02:24:20 <b_jonas> and you should expose a functional interface for when you don't want to use the printf-like patterns, like you asked for
02:24:22 <ais523> nowadays Rust lets you do "{x:.2f},{y:.2f}" and it uses the values of the vairables x and y
02:24:31 <ais523> this is horrifying to me but might make more sense from your point of view
02:25:19 <ais523> oh! the best syntax would probably be something like println!(x[0]:.2 "," y[0]:.2)
02:25:26 <b_jonas> I kind of don't like the embedded expressions, but I admit that part might just be bias because I'm used to the separate arguments
02:25:49 <ais523> putting the embedded expressions outside the string
02:26:12 <ais523> this is basically what Perl print (as opposed to printf) does
02:37:24 -!- joast has joined.
02:48:57 <esolangs> [[Semi-serious language list]] https://esolangs.org/w/index.php?diff=170473&oldid=170453 * Xysdd * (-19) not original
02:51:33 <esolangs> [[Semi-serious language list]] https://esolangs.org/w/index.php?diff=170474&oldid=170473 * Xysdd * (-19) unoriginal and WIP
04:21:28 <korvo> Well, I think I've made a wrong turn at Alberquerque, so to speak; I'm looking up how to find and kill grandchildren and ISTR that this is an indication that everything has gone wrong.
04:22:33 <korvo> I'm thinking about how to implement ejectors for Vixen. The key thing I need to do is detect when I'm in a nested execve(), find a matching process further up the call stack, and kill all intermediate processes.
04:25:27 <korvo> I guess that I want a way to cancel a process tree. But I don't want to have to set up a supervisor tree any time that I need an ejector.
04:27:54 <korvo> Oh, I can just use a process group. The nested execve() will kill itself, but I can arrange for it to do its work first.
04:28:42 <ais523> do process groups nest correctly?
04:31:00 <ais523> looks like they don't (but depending on what you're doing, they might not need to)
04:34:35 <korvo> I want to write Vixen like `Ejector escape: [:ej|...]` where the body of the nested block returns a value. This means running a process that takes `ej` as its argv[2] and collecting its stdout. The value of the nested block is the value of the whole expression, *except*...
04:35:28 <korvo> ...if the body ever runs `ej eject: "some human-readable label"` then the entirety of the block is canceled and evaluates to whatever was ejected. Even if it's deeply nested.
04:37:56 <ais523> I wonder if continuation passing style would be a good solution here – especially as that's basically how execline works
04:38:31 <ais523> also I'm confused because execve ends the process that calls it, so there wouldn't be matching process higher up
04:39:01 <ais523> but you need to think about what happens if you have two nested ejectors, users would expect to be able to eject to either the inner or the outer one
04:40:27 <korvo> Smalltalk blocks are basically continuations. But they're multi-use undelimited continuations; they can do anything and don't have to return. E-style ejectors are single-use delimited continuations. The extra discipline lets them implement break/return/continue without having to trust that the called method is correctly going to exit when it's done.
04:41:04 <korvo> Yes! Process groups won't work because the outer ejector needs to also kill the inner ejector somehow.
04:41:34 <korvo> Hm. setsid() isn't actually privileged, so I could just start a new session instead. But those can't nest either.
04:42:05 <korvo> ...Oh no. You know what does nest on Linux? cgroups.
04:43:04 <ais523> one thing that I'm curious about is how esoteric a project Vixen is meant to be
04:43:37 <ais523> are you creating a language that works like this purely because it's expected to be fun/interesting, or do you have a practical use for it? (this is #esoteric, both answers are acceptable)
04:44:13 <ais523> and setsid() can't be privileged, otherwise you'd need root permissions to open a terminal emulator
04:44:42 <korvo> I am cleaning up my homelab. The Smalltix convention is helping me organize various scripts by augmenting directories with behavior. I have a SymlinkFarm object, for example; it gives a directory of symlinks the ability to index and mutate itself.
04:45:23 <sorear> I know you're old enough to remember /dev/ptyXX
04:45:49 <ais523> sorear: there have always been workarounds for pty creation
04:45:51 <korvo> The name is chosen so that, in the unlikely event that I adapt s6 and fork SixOS, I can justify calling the Linux distro "Vixen" as well, with Xenia as the mascot. But we all know that I love running my mouth about planned projects that go nowhere.
04:46:01 <ais523> but you need to be able to setsid to link the terminal emulator to the pty
04:46:26 <korvo> I had thought that getty, sshd, etc. were started with extra permissions somehow, TBH. TIL.
04:46:31 <ais523> I can't remember what people did before getsid
04:46:46 <ais523> korvo: xterm needs to setsid too
04:47:10 <ais523> otherwise, foregrounding a process in one xterm would background all the processes in other xterms you were running
04:47:43 <korvo> ais523: I thought that *that* was given by some sort of X11 magic credential. I've learned to not underestimate how much authority is smuggled through X11 login.
04:48:52 <korvo> I had thought that tmux, screen, abduco, etc. have a special magic page of assembly which does some evil stuff to manage terminal access. I *did* since learn, a few years ago, that it can be done in portable C.
04:49:46 <korvo> Past Corbin sure didn't know much about Linux. Honestly, must have been nice for Past Corbin. Ignorance is bliss.
04:50:01 <ais523> I think the hard part of all this is that there are a lot of things that go on with this sort of thing, with various levels of magic
04:50:15 <ais523> sometimes the problem is a mess of daemons and weird libraries and rarely used permissions
04:50:25 <ais523> and sometimes there's just a system call that does exactly what you need
04:51:08 <korvo> Yeah. Like, one of my side questions that I haven't settled is how exactly to call openat2(). I might just have a Rust binary that does it.
04:51:11 <ais523> (there is some crazy magic here: if you call setsid() and then open a terminal, the session gets linked to the terminal)
04:51:42 <ais523> open has an option to *not* be magic, but you have to turn it on intentionally, it does the magic by default
04:52:52 <ais523> actually this really troubles me, this is (while convenient) pretty much nonsenical from an API perspective
04:54:17 <ais523> it's probably a historical accident where someone wanted to write a terminal emulator and ended up writing it partly in userspace and partly in the kernel because that's what was most convenient, and now POSIX has a bizarre magic libc call for backwards compatibility with other terminal emulators that did the same thing in order to make use of the available APIs
05:03:40 <korvo> https://unix.stackexchange.com/a/450242 Found an answer with cgroups in mind. Quoting the attached PR, "This allows to conveniently kill the entire process tree below the forked program, a common problem when scripting tasks that need to reliably fully terminate without leaving reparented subprocesses behind."
05:04:13 <korvo> ais523, sorear: Thanks for the rubber-ducking. I'd apologize for all the stupid questions, but at least this one had a smart answer.
05:04:33 <korvo> And the air fryer just finished the baked potatoes! Truly this is a great evening.
05:04:55 <ais523> korvo: right, it might be a weird context in which the problem arose, but that doesn't mean that the problem itself isn't sensible
05:05:44 <korvo> ais523: It's very analogous to being able to unwind a stack. In general, that's a weird thing to want. But if implementing exception handling, or continuations, then it's actually essential.
05:06:30 <ais523> right – I noticed the analogy, just wasn't quite sure what it meant for Vixen
05:06:50 <korvo> "very analogous"? What a phrase. So tired. I'm demonstrating that I can do all my New Year's resolutions in one day, including an hour of yardwork this morning and 2.5hrs of running Zelda 3 in public.
05:07:50 <korvo> TBH I don't actually know what Vixen should be. I'm going to take Jakubovic's analogy as far as I can; how much of E-style secure-distributed computing can we do with directories and processes? Do I *need* vats? Are auditors possible or good?
05:16:24 <esolangs> [[Caten]] N https://esolangs.org/w/index.php?oldid=170475 * Timm * (+345) Created page with "use [[Cq+]] this is engine use "caten" has [sprite].set pos [x] [y] rot [rot] if [var] > [value] to [code] else [code2] if [var] < [value] to [code] else [code2] if [var] = [value] and [var] = [value] to [code] else [code2] /# and so on #/ [sprite].change pos [x]
05:16:27 <esolangs> [[Cq+]] N https://esolangs.org/w/index.php?oldid=170476 * Timm * (+407) Created page with "{{stub}} Cq+ or cqut is esolang for engine [[Caten]] use "[name of class group or plugin]" class [class] [class name].[var name] = [value] ... name [function] to [code] /# or #/ name [function] to { [code] } end sub [int2] from [int] add [int] and [int]
05:20:40 <esolangs> [[User:Timm]] https://esolangs.org/w/index.php?diff=170477&oldid=170318 * Timm * (+94)
05:25:56 <esolangs> [[Kool]] https://esolangs.org/w/index.php?diff=170478&oldid=170472 * Yayimhere2(school) * (+9) this is also a stub.
05:50:55 -!- pool has quit (Ping timeout: 240 seconds).
05:51:29 -!- pool has joined.
06:05:25 <esolangs> [[Bitdeque]] https://esolangs.org/w/index.php?diff=170479&oldid=75993 * Yayimhere2(school) * (-293) /* Computational class */ I actually tried doing the proof, and it didnt work. Im deleting the category.
06:23:58 <esolangs> [[Bitdeque]] https://esolangs.org/w/index.php?diff=170480&oldid=170479 * Ais523 * (+1406) TCness proof it might be possible to directly do a Minsky machine with this, but the proof via cyclic tag is very simple and direct so I decided to use that instead
07:22:38 -!- Yayimhere has joined.
07:41:18 -!- ais523 has quit (Quit: quit).
07:53:26 -!- ais523 has joined.
08:02:36 -!- Sgeo has quit (Read error: Connection reset by peer).
09:03:57 -!- tromp has joined.
09:19:47 -!- Yayimhere has quit (Ping timeout: 272 seconds).
09:22:56 -!- Yayimhere has joined.
09:42:44 <esolangs> [[Cq+]] M https://esolangs.org/w/index.php?diff=170481&oldid=170476 * JIT * (+24)
09:47:03 <esolangs> [[IMAGERY]] M https://esolangs.org/w/index.php?diff=170482&oldid=169822 * JIT * (+9)
09:55:44 <esolangs> [[B9]] M https://esolangs.org/w/index.php?diff=170483&oldid=167949 * JIT * (+66)
09:57:09 <esolangs> [[B9]] https://esolangs.org/w/index.php?diff=170484&oldid=170483 * Yayimhere2(school) * (+9) not very detailed, or in other words, {{stub}}
10:22:54 -!- chomwitt has joined.
10:39:31 <APic> Just breakfasting Vegetable Juice
10:39:34 <APic> Yayimhere: And You?
10:40:04 <Yayimhere> ive been writing some semi formal string rewriting systems
10:42:55 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
10:45:24 -!- tromp has joined.
11:10:59 -!- Yayimhere has quit (Quit: Client closed).
11:50:34 <esolangs> [[User talk:None1]] https://esolangs.org/w/index.php?diff=170485&oldid=170458 * None1 * (+309) /* SLet */
12:08:59 <esolangs> [[Navrytl]] N https://esolangs.org/w/index.php?oldid=170486 * PrySigneToFry * (+10839) Created page with "Navrytl is designed by PSTF. It is Brainfuck equivalent in Timeline 284436. In that universe, it is designed by Maiquel Quehuacetzel, is also a big fan of Aztec culture. His real name is Mike Quitrys. = Overview = Navrytl(in fact it should be nahuitl but Mike m
12:44:11 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
13:11:44 -!- ais523 has quit (Quit: quit).
13:20:01 -!- ais523 has joined.
13:40:56 -!- Everything has quit (Quit: leaving).
14:00:03 <esolangs> [[Syntaxing]] N https://esolangs.org/w/index.php?oldid=170487 * Timm * (+406) Created page with "{{stub}} digit => "0"|"1"|"2"|"3"|"4"|"5"|"6"|"7"|"8"|"9" number => (""|"-")&[digit] lcl => "a"| #oops :3 add info number2 => {"-"}&[digit] def *name* *args* -> command macros *name* *args* -> return valid "print" *text* valid number [[brainfuck]] syntax valid "
14:00:40 <esolangs> [[User:Timm]] https://esolangs.org/w/index.php?diff=170488&oldid=170477 * Timm * (+17)
14:03:45 -!- tromp has joined.
14:29:26 <esolangs> [[IMAGERY]] https://esolangs.org/w/index.php?diff=170489&oldid=170482 * * (+27)
14:29:51 <esolangs> [[Esolang:Candidates for deletion]] https://esolangs.org/w/index.php?diff=170490&oldid=168377 * * (+14)
14:30:19 <esolangs> [[User:/esolangs]] https://esolangs.org/w/index.php?diff=170491&oldid=169959 * * (-13)
14:35:45 -!- impomatic has joined.
14:50:43 -!- Sgeo has joined.
15:02:31 -!- ais523 has quit (Quit: quit).
15:03:53 <esolangs> [[Talk:IMAGERY]] N https://esolangs.org/w/index.php?oldid=170492 * Yayimhere2(school) * (+182) Created page with "This language is impossible. How would you make an interpreter? --~~~~"
15:05:00 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
15:06:10 <esolangs> [[User talk:Waffelz]] https://esolangs.org/w/index.php?diff=170493&oldid=169596 * Yayimhere2(school) * (+205) /* Tea */
15:10:23 -!- tromp has joined.
15:32:12 <esolangs> [[User talk:Stkptr]] M https://esolangs.org/w/index.php?diff=170494&oldid=162160 * Nguyendinhtung2014 * (+212)
15:41:56 -!- amby has joined.
16:53:43 -!- sprock has quit (Ping timeout: 240 seconds).
16:53:51 <esolangs> [[User talk:Stkptr]] https://esolangs.org/w/index.php?diff=170495&oldid=170494 * Yayimhere2(school) * (+273) /* Coincidence? */
17:05:07 <esolangs> [[Esolang:Candidates for deletion]] https://esolangs.org/w/index.php?diff=170496&oldid=170490 * Corbin * (+913) Organizing and proposing policy.
17:05:42 -!- sprock has joined.
17:06:00 <korvo> ^^ I am going to start proposing deletion policy. Please discuss any concerns you might have, as this is the sort of thing that we don't want to get horribly wrong.
17:10:34 <korvo> Crucially, given the wiki's size and the number of deletions that occur, I'm not proposing the same sort of consensus-seeking approach used on English WP. We can do that on a case-by-case basis if people want, but right now it seems like the main issue is one of *enumerating* what has already been agreed to be deleted.
17:27:36 <esolangs> [[Semi-serious language list]] https://esolangs.org/w/index.php?diff=170497&oldid=170474 * Yayimhere2(school) * (-49) /* U */ Unary isnt special enough(its one of the most trivial ideas of how to make a variant of a language).
17:37:22 <esolangs> [[User:Deltayelta/Dredge]] https://esolangs.org/w/index.php?diff=170498&oldid=169858 * Deltayelta * (+1396) wow I just wrote a bunch
17:37:46 <esolangs> [[Special:Log/newusers]] create * MEMORY * New user account
17:51:02 -!- lynndotpy6093 has quit (Quit: bye bye).
17:52:03 -!- lynndotpy6093 has joined.
18:04:07 <esolangs> [[The code is a maze]] N https://esolangs.org/w/index.php?oldid=170499 * Hammy2 * (+1111) Created page with "'''The code is a maze''' is a [[Zame]]-inspired esolang by [[User:Hammy]] ==Execution== The program is a maze made out of characters that can be anything. The first part of execution is the solving. The "solver" will start solving the maze at the top-left co
18:21:23 <esolangs> [[Talk:IMAGERY]] https://esolangs.org/w/index.php?diff=170500&oldid=170492 * Hammy2 * (+181)
18:23:06 <esolangs> [[User talk:]] https://esolangs.org/w/index.php?diff=170501&oldid=170046 * Hammy2 * (+65) /* Signature length */
18:30:59 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
18:33:25 <esolangs> [[User talk:]] https://esolangs.org/w/index.php?diff=170502&oldid=170501 * Aadenboy * (+452) /* Signature length */
18:39:26 <esolangs> [[User talk:Hammy/signature]] N https://esolangs.org/w/index.php?oldid=170503 * Aadenboy * (+385) Created page with "just letting you know, all of your messages signed using this template say they were posted at the same time ~~~~"
18:39:38 <esolangs> [[User talk:Hammy/signature]] https://esolangs.org/w/index.php?diff=170504&oldid=170503 * Aadenboy * (+13)
18:57:54 -!- tromp has joined.
19:21:44 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
19:31:50 -!- Lord_of_Life_ has joined.
19:31:57 -!- Lord_of_Life has quit (Ping timeout: 252 seconds).
19:34:34 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
19:57:52 -!- tromp has joined.
21:27:02 -!- impomatic has quit (Quit: Client closed).
21:28:49 <esolangs> [[Language list]] M https://esolangs.org/w/index.php?diff=170505&oldid=170415 * Buckets * (+10)
21:29:27 <esolangs> [[User:Buckets]] M https://esolangs.org/w/index.php?diff=170506&oldid=170362 * Buckets * (+9)
21:29:40 <esolangs> [[Pab]] N https://esolangs.org/w/index.php?oldid=170507 * Buckets * (+1490) Created page with "Pab Is an esoteric Programming Language created by [[User:Buckets]] In 2021. {| class="wikitable" |- ! Commands !! Instructions |- | Any readable ASCII character. || Set the value To That ASCII Character. |- | Any unreadable ASCII character. || End the Program. |- | || Pr
21:30:48 <esolangs> [[User:Buckets/Sandbox]] M https://esolangs.org/w/index.php?diff=170508&oldid=158541 * Buckets * (+4001)
21:35:54 <esolangs> [[Pab]] M https://esolangs.org/w/index.php?diff=170509&oldid=170507 * Buckets * (-10)
21:47:08 -!- chomwitt has quit (Ping timeout: 260 seconds).
22:13:33 <esolangs> [[User talk:Waffelz]] https://esolangs.org/w/index.php?diff=170510&oldid=170493 * Waffelz * (+140)
22:29:47 <int-e> AAARGH why did I spend so much time on today's AoC.
22:37:27 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
22:38:43 -!- pool has quit (Quit: The Lounge - https://thelounge.chat).
22:38:59 <esolangs> [[Vixen]] https://esolangs.org/w/index.php?diff=170511&oldid=170008 * Corbin * (+2304) /* Core */ A possible way to do ejectors. I don't know if it's possible to avoid the TOCTTOU without directly doing some syscalls.
22:39:12 -!- pool has joined.
22:41:04 -!- pool has quit (Client Quit).
22:41:30 -!- pool has joined.
22:45:37 -!- pool has quit (Client Quit).
22:46:20 -!- pool has joined.
22:47:29 <esolangs> [[ASTLang]] https://esolangs.org/w/index.php?diff=170512&oldid=169634 * NTMDev * (+826) /* Sort */
22:48:42 <esolangs> [[ASTLang]] https://esolangs.org/w/index.php?diff=170513&oldid=170512 * NTMDev * (+187) /* Zip */
22:49:31 <esolangs> [[Mov]] M https://esolangs.org/w/index.php?diff=170514&oldid=162185 * Somefan * (+64) Lowercase and formatting
22:51:31 <esolangs> [[ASTLang]] https://esolangs.org/w/index.php?diff=170515&oldid=170513 * NTMDev * (+178) /* Zip */
22:51:50 -!- tromp has joined.
22:53:40 -!- pool has quit (Quit: The Lounge - https://thelounge.chat).
22:54:06 -!- pool has joined.
23:03:36 <esolangs> [[ASTLang]] https://esolangs.org/w/index.php?diff=170516&oldid=170515 * NTMDev * (+135)
23:05:36 <esolangs> [[ASTLang]] https://esolangs.org/w/index.php?diff=170517&oldid=170516 * NTMDev * (+330) /* Shuffle */
23:09:52 <esolangs> [[ASTLang]] https://esolangs.org/w/index.php?diff=170518&oldid=170517 * NTMDev * (+550) /* Shuffle */
23:12:14 <esolangs> [[ASTLang]] https://esolangs.org/w/index.php?diff=170519&oldid=170518 * NTMDev * (+116) /* Sample */
23:13:38 <esolangs> [[ASTLang]] https://esolangs.org/w/index.php?diff=170520&oldid=170519 * NTMDev * (+124) /* Flatten */
23:13:53 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
23:14:26 -!- ais523 has joined.
23:27:24 <esolangs> [[ASTLang]] https://esolangs.org/w/index.php?diff=170521&oldid=170520 * NTMDev * (+31) /* Flatten */
23:33:26 <esolangs> [[ASTLang]] https://esolangs.org/w/index.php?diff=170522&oldid=170521 * NTMDev * (+616) /* Flatten */
23:34:27 <esolangs> [[ASTLang]] https://esolangs.org/w/index.php?diff=170523&oldid=170522 * NTMDev * (+105) /* Flatten */
23:58:28 <esolangs> [[Human-81]] N https://esolangs.org/w/index.php?oldid=170524 * A() * (+788) Created page with "Human-81 is an Esolang made by [[User:A()]] for humans. It was designed to be simple to read, but also with less commands than other languages. ==Commands== {| class="wikitable" |+ Commands |- ! Cmd !! Header text |- | Start, (Name), with (inputs). || function |- | End