00:02:45 -!- Lord_of_Life has quit (Ping timeout: 274 seconds).
00:17:20 -!- sftp has quit (Ping timeout: 262 seconds).
00:35:01 -!- sftp has joined.
00:35:19 -!- sftp has changed hostmask to ~sftp@user/sftp.
00:38:50 -!- Lord_of_Life has joined.
01:09:30 -!- MarkFan8901 has joined.
01:12:19 <MarkFan8901> is this a good place to ask for language help?
01:16:32 <zzo38> Do you have a specific question about it?
01:17:05 <MarkFan8901> really we just need some other ppl to bounce ideas off of
01:18:42 <MarkFan8901> its a string rewriting language which we wanna design specifically around compilation/interpretation of other programming languages
01:22:05 <MarkFan8901> the general way programming would be done is by having two files, the program (the thing ralsei actually runs) and the input (the thing the program works on)
01:23:21 <MarkFan8901> firstly, the ability to 'pass through' things from the input into the program
01:23:45 <MarkFan8901> to give the ability to create languages with truly arbitrary syntax
01:25:26 <MarkFan8901> ie (at a very high level) some baloney like `(new rule, infix addition, "%a + %b", (+, a, b)) (display, 1 + 2) ; would print 3`
01:26:36 <MarkFan8901> secondly, we want whatever system we use for that to be pretty practical
01:28:05 <MarkFan8901> ie easy support for stuff like libraries and whatnot
01:29:27 <MarkFan8901> but the main premise is a language to write other languages in, with the power cranked up to 11
01:29:53 <korvo> The relevant page on the wiki is a bit short: https://esolangs.org/wiki/Metalanguage
01:30:31 <korvo> Were there specific libraries that you were hoping to integrate?
01:31:04 <MarkFan8901> nono by libraries we meant like, itd be easy to write and use libraries written within the language
01:31:35 <korvo> Ah, like modules or theories or other sorts of extensions. Somebody Else's Code.
01:32:03 <MarkFan8901> we are. VERY conflicted with how to go about anything more specific than that
01:33:03 <MarkFan8901> like we keep getting torn between 'it should have useful features pre-implemented' and 'those should be implemented from within the language so the primitives can build equally fundamental things'
01:33:42 <MarkFan8901> ie if the regex * should be a primitive or if it should be implemented
01:33:46 <b_jonas> MarkFan8901: how would that work? what would determine the semantics of that operator. is the "addition" that you mention a library function that has semantics, and you're just binding the "+" operator to it?
01:34:30 <b_jonas> also this has nothing to do with the RASEL language, right? the name just sounds simlar.
01:36:21 <MarkFan8901> the example is a comically high-level one but the gist is that, internally, a rule `[variable] [whitespace] "+" [whitespace] [variable] -> "(+," [variable] "," [variable] ")" gets made
01:36:44 <korvo> Have you looked at parser-oriented compilers like META II? We have an article on it: https://esolangs.org/wiki/META_II
01:37:21 <MarkFan8901> then that rule would be checked for before anything else when parsing the next expressions
01:37:39 <korvo> Also, have you looked at languages like Haskell (or Agda, Idris, etc. in that family) that allow custom operators? This trick works by defining a big class of random punctuation characters as legal tokens for new operators.
01:38:13 <MarkFan8901> yea but those have pre-defined syntactic rules for how they work
01:38:33 <MarkFan8901> we wanna make it so that you can have *truly* arbitrary syntax
01:39:10 <MarkFan8901> like you could take a lisp implementation with syntax redefining and turn it into a c interpreter from within the language itself
01:40:21 <MarkFan8901> the way that the example we gave above and like how the language would 'know' whats a variable and whatnot would be left to the implementation of the given lisp in ralsei
01:40:45 <MarkFan8901> we just used lisp cuz thats the canonical example in our head
01:41:10 <MarkFan8901> it's just meant to illustrate what we're talking about
01:42:26 <MarkFan8901> the problem is we're torn on nearly everything about how we should design ralsei itself
01:43:31 <korvo> Sure. I struggled with this for Zaddy, too. That's a META II fork. The "restricted" version of Zaddy still looks like META II; I have no idea what the "unrestricted" syntax will look like. https://esolangs.org/wiki/Zaddy
01:44:27 <korvo> That said, S-expressions will work and they are easy to parse. There's no reason to commit to a hard-to-parse meta-syntax. There are languages that are super-rich and hard-to-parse and with builtin parsing tools, like Raku or Janet, but they take a lot of effort to get the details right.
01:46:47 <korvo> MarkFan8901: Oh, another big question: do you want to be able to implement *optimizing* compilers, or is it enough to simply emit valid code? The more optimizations you want, the more you'll need some sort of general-purpose tools.
01:47:41 <MarkFan8901> hold on hold on we think we introduced some confusion with the lisp example
01:47:55 <MarkFan8901> the lisp example would be the *input* for a ralsei program
01:48:26 <korvo> Oh! What kind of syntax were you thinking for ralsei itself? Some sort of BNF?
01:49:34 <MarkFan8901> we're actually thinking of making ralsei in a binary format
01:51:24 <MarkFan8901> like for example we keep thinking about like if the instructions should work like functions
01:51:34 <korvo> And, really, what's the difference between text and binary? So it sounds like very little is decided.
01:52:03 <MarkFan8901> yeah very little is decided specifically because we're so torn between everything we *could* do
01:52:03 <korvo> How do you want to identify and rewrite hunks of input? Do you want structures for input? Types?
01:54:21 <MarkFan8901> we've thought about basing execution around typical string rewriting systems, where the 'recognition' phase would be checking for all chunks of text that follow a certain pattern, then the 'rewriting' phase would operate on the chunks in question
01:55:37 <MarkFan8901> we've thought about having recognition and rewriting split in two, where you could first recognize all pieces of text that follow a certain rule, *then* rewrite them
01:56:49 -!- sprock has joined.
01:56:50 <MarkFan8901> we've thought about having execution resemble more traditional machine code, of course still with weird oddities
01:57:53 <MarkFan8901> which is actually kind of where we are right now
01:58:22 <MarkFan8901> and we've also thought about ditching *string* rewriting entirely and basing it in *tree* rewriting instead
01:58:54 <MarkFan8901> like we just cant choose one thing to follow through on
02:00:27 <korvo> Yeah. I ended up implementing a couple whitepapers for Zaddy. I do E-graph rewriting; I found a paper that turns it into a database-query problem, and implemented it as an in-memory hierarchy of database tables.
02:01:03 <korvo> This approach requires types, one way or another, because I need to emit code for each table, and each constructor has to be associated to the correct table.
02:02:23 <MarkFan8901> the way we're imagining ralsei compiles/interprets languages is by 'sifting' down the input until it just *is* the compiled/interpreted result
02:02:50 <korvo> Matching is computationally tricky. Tree rewriting is really easy because we can implement it as katamorphisms (or paramorphisms, etc.) and those are compiled down to recursive procedures. The only difficulty is traversing the tree.
02:02:53 <MarkFan8901> similar to a paper we saw about compiling lisp by gradually turning it into assembly but we cant remember it :sob:
02:03:36 <korvo> But as the tree overlaps with itself more and more, the underlying algorithms get nastier. For DAGs, which are just trees that can share some branches, the best algorithms are variants of NOLTIS. Linear time, more or less, but hard to think about.
02:03:36 <MarkFan8901> this is a big part of why we have an entire pratical/bootstrapping split in our head
02:04:41 <korvo> I'm terrible at mind-reading but I'm guessing Ghuloum 2011, "An incremental approach to compiler construction" http://scheme2006.cs.uchicago.edu/11-ghuloum.pdf
02:04:54 <korvo> Which is a great paper, really insightful, thanks for recommending again.
02:05:46 <MarkFan8901> this might be it? not sure but we'll go back through it later
02:05:58 <MarkFan8901> it might actually be better to step back and talk about another langauge we thought of
02:06:29 <MarkFan8901> yknow the whole central premise of parsing, right?
02:06:36 <MarkFan8901> turning a string of text into an abstract syntax tree
02:07:09 <MarkFan8901> according to a given set of rules that determine how the tree should be built
02:08:21 <korvo> Sure. Or just recognizing that a string fits a grammar.
02:08:27 <MarkFan8901> the rules can use the raw string, as well as elements from the tree, to create new parts of the tree
02:10:02 <MarkFan8901> typically there's some unspoken rules in place when making this tree
02:10:57 <MarkFan8901> ie you cant destroy parts of the tree which already exist, and you generally dont want to make the top of the tree bigger than before
02:11:54 <MarkFan8901> i.e. a rule which makes two leaves of the tree that contain the same part of the program string at the same time
02:12:11 <MarkFan8901> if you *dont* follow these, rules, then uh
02:14:22 <MarkFan8901> theoretically, you could have a language whose *syntax* is turing complete, as in the program which successfully turns a given piece of source code in the language to its' corresponding syntax tree is capable of universal computation
02:15:15 <korvo> Yeah, that happens sometimes. Perl 5 is a classic example.
02:15:16 <MarkFan8901> this is very funny, but one of the main implications of this is that 'rules' for string recognition are actually programs
02:15:36 <MarkFan8901> oh this is different from the other 'you cant parse [blank]' examples we've seen
02:16:04 <MarkFan8901> you "can't parse" perl 5 because you can make the parser run perl 5 code
02:16:14 -!- sprock has quit (Ping timeout: 245 seconds).
02:16:35 <MarkFan8901> we consider that cheating because that's just passing the semantics of perl 5 through the syntax
02:17:50 <MarkFan8901> what we mean is that the mere act of turning a string in that programming language into its' correct syntax tree is turing complete
02:18:13 <MarkFan8901> just to drive the point home we also imagine that said languages' semantics wouldnt be turing complete
02:18:47 <korvo> Hm, is it really possible to disconnect the semantics from the syntax in that direction?
02:20:46 -!- MarkFan9801 has joined.
02:21:14 <MarkFan9801> cuz you could just make the final tree like, some dialect of deadfish or smth
02:22:05 <MarkFan9801> but the funny part is that you coudl still write turing-complete programs in it
02:22:24 <MarkFan9801> by *passing the syntax through the semantics*
02:22:38 <MarkFan9801> in the same way perl 5 or latex can pass the semantics through the syntax
02:23:28 <korvo> I guess? I'm thinking in subsets. Let P* be the set of all of the strings made from the valid letters of the language. If parsing some subset S of P* is Turing-complete ("TC" is fine in this channel, BTW) then we can't decide whether some element of P* is an element of S.
02:23:47 -!- MarkFan8901 has quit (Ping timeout: 260 seconds).
02:24:55 <korvo> But then what we mean by "semantics" is really important. If we mean the entailments of the native type theory, then given two programs P1 and P2, and the question of whether P1 reduces to P2, we have to establish that both P1 and P2 are elements of S. But that's undecidable twice over.
02:25:01 <MarkFan9801> anyways that implies that, even with less extreme examples, 'rules' for string recognition are programs in their own right
02:25:15 <MarkFan9801> srry we didnt see what you said we were scrolled up
02:25:25 -!- MarkFan9801 has changed nick to MarkFan8901.
02:25:44 <korvo> Oh, for sure. I'm reminded of Prolog's DCG formalism, which blends the grammar rules with an ambient backtracking state-management system.
02:26:03 -!- amby has quit (Remote host closed the connection).
02:26:05 <korvo> No worries. I'm in no rush and it's nice to talk to folks who have done their research.
02:26:35 <korvo> Also, I *really* want to finish Zaddy this year, so I'm eager for anything that I haven't read yet. I want to solve the ACE-matching problem, and I feel that I'm really close.
02:27:17 -!- lisbeths has quit (Quit: Connection closed for inactivity).
02:27:19 <MarkFan8901> to respond to your statement, what we mean by semantics is simply the meaning assigned to different parts of the syntax tree
02:28:31 <korvo> Sure. Presumably that meaning is homomorphic, which just means that the detailed structure of the tree is preserved by the semantics. If that's the case then we can bring a powerful toolbox from maths, category theory, to our aid. A lot of things become free for rewriting systems in general, whether over strings or trees.
02:29:47 <MarkFan8901> ie if you have an if/then/else statement, where the nodes of the tree are the condition and the two blocks of code that correspond to the then/else clauses
02:30:23 <MarkFan8901> the semantics are just, if its true then statement is equivalent to the then block
02:30:52 <esolangs> [[2-SSI]] M https://esolangs.org/w/index.php?diff=190080&oldid=189986 * Marcus 2n2 * (+33)
02:30:54 <MarkFan8901> that's what underpins how we think ralsei would *interpret* programs
02:31:30 <esolangs> [[2-SSI]] M https://esolangs.org/w/index.php?diff=190081&oldid=190080 * Marcus 2n2 * (+2)
02:31:37 <MarkFan8901> compiling programs would just be taking the syntax tree and 'translating' it into the desired form
02:32:29 <korvo> Sure. That sort of optimization is closely related to *partial evaluation*, which is an entire thing on its own in compiler theory. I'm more than happy to talk about it, and about JITs too, but often folks find that too complicated.
02:33:47 <korvo> There's also the ideas of normalization by evaluation ("NBE") and compiling-to-closures, which both are ways of compiling e.g. lambda calculus by compiling to a higher-order program that takes lambda terms as input and output.
02:34:24 <korvo> And more generally, multi-stage programming with quoting and unquoting. The complexity tower goes all the way up if you want to talk about metainterp.
02:35:37 <MarkFan8901> uhh we forgot what we were gonna say next give us a sec
02:35:55 <korvo> No worries. I've been around the block a few times. I've also tried out a lot of things. I'm trying to give you a lot of options without telling you what I think you ought to do.
02:36:29 <MarkFan8901> the primary issue is that we dont know how to just lock in and pick one
02:36:48 <MarkFan8901> cuz nothing we've really thought of has fully satisfied us yet
02:37:01 <MarkFan8901> though we think talking more about the intent of what we wanna do is starting to help
02:37:32 <korvo> Y'all might have to do a few experiments. Build a couple little toys that can only barely parse themselves. For metacompilers, it sounds annoying (and kind of is) but you'll want to hand-write the first fixed point.
02:37:52 <MarkFan8901> like the problem is we have too *many* options and we aren't skilled in how to think about them clearly
02:38:35 <korvo> Like, 500 lines of Python hand-written for a 50-line grammar. It's not the end of the world, but it will be a bit of a slog. I think it's fun, but I also used to debug GPU drivers by hard-resetting my machine dozens of times per day and I speedrun randomizers, so I'm a little twisted.
02:39:18 <MarkFan8901> oh actually we do already have quite a few lines of c code (we wanna implement this in c) that implement cut buffers
02:40:34 <korvo> I mean y'all will have two artifacts in your repo: one in Ralsei and one in C. The Ralsei document is your actual compiler and the C code is just a fixed point in the sense that `compiler(c) = c` should be true-ish.
02:41:00 -!- sprock has joined.
02:41:03 <korvo> But it's also okay if you start with some jank C that only barely works, generate a nicer pile of C, and then distribute the nicer version.
02:41:05 <MarkFan8901> also we like how you switched to saying yall instead of you
02:41:23 <korvo> esolangs: Is there such a thing as non-jank C?
02:41:28 <MarkFan8901> if ur wondering why we say we its cuz we're a split personality (long story short)
02:41:42 <esolangs> korvo: "Non-jank" C is a bit of a paradox. C itself is a low-level language, meaning it's close to the hardware. This means it's inherently prone to performance issues like jank. However, you can minimize jank in C by: * **Careful code optimization:** Minimize unnecessary operations, use efficient data structures, and leverage compiler optimizations. *...
02:41:42 <esolangs> **Modern C++ features:** C++ offers features like templates and smart pointers that can improve performance and reduce memory management overhead. * **Focusing on the right tools:** Use a good compiler, profiling tools, and a well-structured codebase. Ultimately, "non-jank" C is a matter of minimizing the potential for performance issues.
02:41:47 <korvo> Sure, whichever y'all prefer. This meatbag knows what it's like to have non-standard pronouns and has a few plural friends.
02:42:46 <korvo> Don't worry, it's a joke. Normally I'd ask fungot, a bot that uses a Markov model written in Befunge, but it's apparently offline.
02:43:03 <korvo> The bot can RAG the wiki, sometimes, if we're lucky.
02:43:17 <korvo> esolangs: Why is META II historically significant?
02:43:23 <korvo> Yeah, there's some real sickos around here~
02:43:57 <korvo> I started editing the wiki and now I know brainfuck. CLV.
02:44:06 <esolangs> korvo: META II is historically significant because it was the first metacompiler to be able to regenerate itself in practice. This groundbreaking achievement, achieved in 1962, demonstrated the potential for self-replicating and evolving computational systems. It paved the way for future research in metaprogramming and the development of more...
02:44:06 <esolangs> sophisticated and adaptable programming languages.
02:44:07 <MarkFan8901> here's why we cant really write a fixed point yet
02:44:47 <MarkFan8901> its because we're stuck on how to even deal with rules and rewriting internally
02:45:02 <MarkFan8901> like okay we should probably also talk about some other ideas we've had for ralsei
02:45:23 <MarkFan8901> firstly, the ability to make and write to external memory thats unrelated to the input program
02:45:46 <MarkFan8901> we're specifically thinking said memory is also in the form of cut buffers because that would be hilarious
02:46:18 <MarkFan8901> + its convenient and would be consistent with the other base operations that would be given in ralsei
02:47:16 <MarkFan8901> its another big point of contention to why we have the practical/bootstrap split, because that also creates a REALLY good argument for why the primitives should be more bootstrappy
02:47:40 <korvo> I haven't done text editors in a while. Are cut buffers like ropes or gap buffers?
02:48:04 <korvo> I get the vibe of a language that's like programming (within) a text editor.
02:48:37 <MarkFan8901> that might be a good starting point actually
02:48:47 <korvo> What kinds of things are you imagining might be primitive-only? Or are there things that you think have to be composites of simpler operations for some reason?
02:49:13 <MarkFan8901> primitive-only stuff is like, moving the cursor in a cut (short for cut buffer)
02:49:46 <MarkFan8901> Oh btw cuts store word-length unsigned integers they aren't just limited to characters
02:49:55 <korvo> Earlier today, on a totally unrelated language (Vixen on the wiki), I realized that I need a "boot" and "user" split for calling conventions. The problem is that "user" calls shouldn't be allowed to do powerful "boot" things and "boot" calls shouldn't bother with fancy "user" markup. This is a common-ish sort of split.
02:50:34 <MarkFan8901> might be relevant but we'll see if that concept comes up again naturally
02:50:46 <korvo> How do y'all want to handle string encoding and codepoints? In Zaddy, I gave up early and said that input and output are both UTF-8 sequences of code points.
02:51:13 <MarkFan8901> oh we were thinking that could be dealt with with rewriting
02:51:54 <korvo> I would hope that a rewriting system doesn't need such a split. More likely there could be a "builtin" vs "composite" split; "builtin" is for stuff like numbers, strings, lists, that the user can't or shouldn't build themselves; "composite" is all about how the user can extend the language with their own concepts.
02:52:07 <korvo> So like raw bytes?
02:52:23 <MarkFan8901> yes we do have that 'builtin' and 'composite' split in our head already
02:53:33 <MarkFan8901> we were thinking you could just write a function which rewrites all the multi-length utf-8 characters into their corresponding codepoint
02:53:44 <MarkFan8901> since values in cut buffers arent limited to just bytes
02:53:53 <MarkFan8901> then you could go on with your merry day after that
02:54:45 <MarkFan8901> you could even write like ebcdic (forgot the specific acronym) to ascii functions which could deal with that encoding natively
02:54:58 <korvo> Yeah. Another approach, IIRC the language was called Boomerang?, was to ask the user to define bijections between everything. Parsing UTF-8 meant defining a bijection between bytes and code points; the compiler did the rest.
02:55:45 <korvo> Yep, https://www.engineering.upenn.edu/~harmony/index.html note the page requires JS enabled.
02:56:19 <MarkFan8901> omw to create a context sensitive text encoding system to completely fuck over that entire strategy
02:56:39 <MarkFan8901> every esolanger and text editor designer will be our nemesis
02:57:04 <korvo> But their approach allowed for every bijection to become a *lens*, a fancy category-theoretic tool that makes it easy to do small changes to a big system. I wrote a couple toy video games with lenses; e.g. updating the ball in a game of pong means updating a lens that picks the ball's state out of the entire game's state.
02:57:37 <korvo> u'i English is context-sensitive, for example. Spacy can parse English but not in poly time.
02:58:19 <MarkFan8901> also we were thinking like, dutch level of context sensitivity
02:58:32 <korvo> Oh, forgot which channel this is. {u'i} is Lojban and translates roughly to "LOL"
02:59:22 <korvo> Sure. I think all natlangs are going to end up as context-sensitive at best. Context is just too useful to ignore in a naturally-evolved setting.
02:59:38 <korvo> Yeah, {korvo} means "crow".
02:59:50 <MarkFan8901> we also have some cool stuff with conlangs but thats a whole nother can of worms
03:01:46 <korvo> Spacy's a Python library for language processing. They figured out a pretty good way to parse English with like 500 lines of Python, or at least that's the meme.
03:02:57 <korvo> Y'all were thinking about bytes as an I/O interface.
03:03:26 <MarkFan8901> and we just instinctively typed 'ye' to ur message
03:04:05 <MarkFan8901> we're not sure where you got io interfaces from honestly
03:04:25 <korvo> I/O is just input and output. Like, input file and output file?
03:04:46 <MarkFan8901> by 'input program' we just meant the thing ralsei programs operate on
03:05:28 <MarkFan8901> things that are definitely builtins are like, moving/inserting/deleting in a cut buffer
03:05:48 <MarkFan8901> things that *could* be builtins are thigns like regex * or +
03:05:58 <esolangs> [[YES WAY!]] N https://esolangs.org/w/index.php?oldid=190082 * Miui * (+244) YES WAY!
03:06:15 <MarkFan8901> but those *could* also be implemented in terms of those primitives
03:06:48 <MarkFan8901> which would also give you more control over how their inputs and outputs are managed
03:06:56 <MarkFan8901> actually this is another big problem we have
03:07:26 <MarkFan8901> whenever we try to write example machine code it likes to converge to a functional style
03:07:56 <MarkFan8901> where you can put instructions into the input field of other instructions
03:08:49 <MarkFan8901> but that doesnt really make sense without the concept of some sort of place to store the intermediate outputs of those instructions in
03:09:49 <MarkFan8901> which poses an immediate disadvantage because you wouldn't be able to interact with whatever system that's used to do that
03:10:14 <korvo> Right. To use some terms from ontology, when we're compiling, we're translating elements of some *domain*, and each domain has its own rules for what an element can *be*. Like, we could say "type", but that's just a label. What matters is that there's multiple domains, and we need some sort of transformation between each pair of adjacent domains.
03:10:59 <korvo> Like, between bytes and cut buffers, since those are two different domains, there ought to be either a domain which can contain both bytes (bytestrings?) and cut buffers as elements, or there needs to be a transformation from one to the other.
03:11:25 <MarkFan8901> we're not talking about turning bytes to cut buffers
03:11:44 <korvo> Similarly, if y'all want instructions to be semantically understood as some sort of operator, then there's going to be some sort of domain of operators, and those operators themselves are subject to transformation.
03:12:21 <MarkFan8901> apologies if we sound kinda rude we're not very good at communicating tone in text
03:13:04 <korvo> Nah, it's fine. I am famously obtuse and often bad with words. Thinking about like five things at once.
03:14:20 <korvo> So yeah, I agree, and "place" has its own frustration because we usually want to relate places to each other in some sort of space. Maybe that space has a metric for comparing places, maybe it has a distance (a "norm"), maybe it has some sort of adjacency between places giving a graph of neighbors.
03:14:22 <MarkFan8901> anyways our main concern here isn't theoretical, having some opaque system for argument passing is bad because that just means you have to implement more stuff
03:14:59 <korvo> Like, cursors in buffers are places, or they're located at places, and that might have to be revealed in the ontology of a text editor just so that they can be manipulated.
03:15:21 <MarkFan8901> oh we plan on exposing as much as possible from within the language
03:15:51 <MarkFan8901> another thing about the character of ralsei is that its comically powerful
03:15:55 <korvo> Yeah. A frenemy of mine talks about "the tyranny of call/return", by which they mean that we have that sort of lambda-ish instinct for subroutines and arguments and passing, all the way down to the hardware, even if we don't want it.
03:17:02 <MarkFan8901> we keep having weird thoughts about how else input and output would be dealt with if it wasnt opaque
03:18:36 <MarkFan8901> so on one hand, having stuff like regex be primitive would feel dirty and hamper the power of ralsei
03:19:13 <MarkFan8901> then on the other hand, we have implementing those things as functions from the primitives
03:19:40 <MarkFan8901> and here's where the *other* can of worms opens
03:20:13 <korvo> Yes. I can talk about how I approached this for Zaddy, but I'll let y'all go for a bit. I got some kitchen stuff to do anyway.
03:20:20 <MarkFan8901> at some point we realized if you had a primitive which switched which cut buffer was being executed, you could reimplement function calling and returning from the ground up
03:21:08 <MarkFan8901> you could also theoretically reimplement the concept of libraries and whatnot
03:21:55 <esolangs> [[Joke language list]] M https://esolangs.org/w/index.php?diff=190083&oldid=189346 * Marcus 2n2 * (+51) /* General languages */
03:22:48 <MarkFan8901> now our HUGE main concern with this is that that could open the floodgates for multiple different mutually incompatible implementations of functions and libraries
03:22:55 <MarkFan8901> and really just about everything as fundamental as that
03:24:04 <MarkFan8901> we think its an issue because we dont expect ralsei to be terse enough that you wont need special libraries to do what you want
03:24:08 -!- kibty has quit (Server closed connection).
03:24:14 <korvo> That's just how things go. Like, here's an example from category theory. If you allow multiple input parameters for a callable, then you allow two mutually-incompatible libraries where every binary callable is switched the "wrong" way around.
03:25:05 <korvo> Oh, like dialects? Or like descendant languages? APL and Forth are both pretty good examples of that in practice.
03:25:54 -!- kibty has joined.
03:26:02 <korvo> Stepping slightly outside that tradition, I love the little language jq, whose standard library is written in itself. It isn't terse enough on its own, but the standard library is short enough that everybody loads it by default.
03:26:28 <korvo> Oh, my roommate got McDonald's. Great. I guess I'm not cooking. Making myself a sandwich instead~
03:27:30 <MarkFan8901> anyways what we mean is that you get enough shit done in your average apl/forth program that you dont *need* libraries to help you out
03:29:40 <MarkFan8901> but like if you need an external program to implement functions and string rewriting youre gonna get a bajillion incompatible implementations of everything in between
03:29:53 <MarkFan8901> thinking about it more this might not actually be as big of an issue as we feel like it is
03:30:46 <MarkFan8901> oh this is probably one of the most fundamental issues we're having
03:31:01 <MarkFan8901> our intentions for what we want this language to be are completely split too
03:33:11 <MarkFan8901> if we had a standard implementation of functions and libraries and whatnot most people would probably use that
03:33:39 <MarkFan8901> but then if other ppl wanted to completely rebuild a different environment from the ground up they could do that too
03:35:08 <MarkFan8901> our thought of something as fundamental as functions having to be implemented in the language itself is basically the thought of making ralsei microcode
03:36:02 <MarkFan8901> for a weird system in which physical memory can be created and destroyed in arbitrary places
03:36:06 <korvo> I made a sandwich and it is good.
03:36:32 <zzo38> Multiple incompatible implementations of stuff is probably inevitable, especially if it is useful for one use but not so good for the other use, then you will need another one. Since, one program (or file format, or character set, etc) will not be suitable for all uses.
03:37:00 <MarkFan8901> we mean like for the REALLY fundamental stuff though
03:37:24 <MarkFan8901> we can accept different ways of reading files or like bnf implementations
03:37:46 <korvo> I hear you. For better or worse, functions are as fundamental as programs and algorithms, so there's no real danger of abandoning them entirely. And going the other direction, language designers love to point at procedures and subroutines and methods and say "function", so whatever~
03:38:36 <MarkFan8901> yea you :sob: didnt call us out at all :sob::sob::sob:
03:39:30 <korvo> Oh, your lambda-abstractions are probably proper! I don't mean that you did anything wrong. Just, like. A function is a mapping from an input set to an output set. A program is a text that controls a machine. An algorithm...is in-between.
03:40:02 <korvo> There's nothing wrong with doing things in terms of functions. (Yet another of my languages, Cammy, is function-only.) It's just not very common.
03:40:11 <zzo38> Some things will need to be a part of the programming language itself, but that depends on the primary working of programming language (which, in the case of esoteric programming, might be more diverse and unusual in some ways compared with more common programming)
03:41:21 <zzo38> Hoever, even when working with instruction sets, not all will use call/return and their working will be differently in different cases, and sometimes you can do unusual stuff with the way it is working. This might also be the case with some esoteric programming languages.
03:42:40 <MarkFan8901> its funny to think we're basically writing a machine code architecture for a string rewriting paradigm
03:43:22 <MarkFan8901> though anyways we're thinking about the specifics of how microcode for working with cuts would work
03:43:46 <MarkFan8901> this whole time we've thought of the cursor of a cut being attached to the cut itself
03:45:07 <MarkFan8901> but would it be better if, from the perspective of the ralsei program, there was a tangible list of values which corresponded to each cuts current position?
03:45:55 <MarkFan8901> oh this reminds us of another annoying problem we have
03:46:25 <korvo> zzo38: WAM, the Warren Abstract Machine underneath some Prologs, is a good example. Erlang's BEAM inherits from it to some degree, as does the De Moura–Bjørner abstract machine. The common thread is pattern-matching, where we want the machine to be able to pause/suspend after each match.
03:47:04 <korvo> However, it's still possible to pattern-match with a more traditional machine. For a good example, check out the LPEG machine which executes PEGs in Lua.
03:47:47 <MarkFan8901> the problem with having any other field of values distinct from the 'main' working memory is that they can be simlated anyways with said memory
03:48:09 <MarkFan8901> just make a new cut and store it in that memory
03:48:22 <MarkFan8901> then use it the way you were using it beforehand
03:48:37 <korvo> MarkFan8901: One approach that might be useful, maybe, is to think like a hardware designer. Actions that are complicated in software are usually complicated in hardware too. A machine is fast because it does a very limited thing, a very small simple thing, maybe a "primitive" thing, very precisely.
03:49:07 <MarkFan8901> we think we need help in thinking this way
03:49:23 <MarkFan8901> specifically in how to 'break down' problems like these
03:53:25 <korvo> There's no shortcut. String rewriting is a totally opaque problem. Y'all get to invent your own structures. I'd recommend developing algebras for those structures and isolating their primitive operations, but I think I'm algebra-brained.
03:54:56 <MarkFan8901> we think the problem is we're averse to structure in the first place
03:55:33 <MarkFan8901> beacuse we feel like it could interfere with something someone else might try to do
03:55:51 <MarkFan8901> spelling it out like that makes it sound ridiculous though
03:59:06 <korvo> I do hear the complaint. I think it's an interesting contrast with the creators of computability theory, who all started with small structures of interest and ended up finding a ceiling of computability in each case.
03:59:42 <korvo> Like, you probably know Church was studying lambda-calculus. Before that, he was working with combinators that showed up repeatedly in mathematical proofs. He was trying to find a way to automate proofs.
04:00:28 <korvo> Turing was studying symbols. Letters in ink on paper. He proved that humans only recognize finitely many different letters, then almost immediately defined Turing machines as the simplest possible way to mathematically talk about humans recognizing letters on paper.
04:01:57 <korvo> Um, to a lesser degree, also Gödel and MRDP were this way. Gödel was studying first-order logic, which is "small" but also ferociously weird. MRDP were studying Diophantine equations, which are literally just polynomials in e.g. natural-number coefficients, been studied for millennia as standard puzzles and toys.
04:02:49 <korvo> Uuum. Matiyasevich, Robinson, David, and Putnam, I think? Did it without looking it up.
04:03:11 <MarkFan8901> we do vaguely remember something about diophantine equations being turing complete
04:03:35 <esolangs> [[YES WAY!]] https://esolangs.org/w/index.php?diff=190084&oldid=190082 * Miui * (+92)
04:03:51 <korvo> https://esolangs.org/wiki/Computable#Via_Diophantine_equations might help a little. These are my notes.
04:04:06 <MarkFan8901> also we should probably make an esolang account
04:04:54 <korvo> Basically, for a Diophantine equation, there's a computation that spits out all of the candidate solutions. Maybe they're valid, maybe not, but for e.g. variables x and y in the nats, you can try (0,0), (0,1), (1,0), (2,0), (1,1), ...
04:06:07 <MarkFan8901> yea we can see how that can get unsolvable very quickly
04:06:18 <korvo> Oh, hm. Do we use integer coefficients on the wiki? Looks like it. It turns out to not matter; Diophantines over ints and nats are the same complexity, and we can enumerate x and y in the ints like (0,0), (1,0), (0,1), (-1,0), (0,-1), ...
04:06:58 <MarkFan8901> theyre all natural numbers from the looks of it
04:07:30 <korvo> Robinson, who IME was a wizard, she proved that we can write down Diophantines which encode a bunch of little number-theory gadgets. She'd been reading Gödel, who was basically the first person to imagine it, and got pretty far.
04:08:26 <korvo> Davis gets credit because they did all the same stuff independently, but Robinson's the one who made the hypothesis that Gödel's theorem can be fully encoded.
04:09:24 <korvo> It is! It's funny how the hard part of all of these computability results is getting started. Like, we have to have the vision to see that some mechanism can be iterated, and that it has some sort of text, and that it has some sort of composite operation...
04:10:04 <korvo> Robinson's hypothesis turns out to be true! There are Diophantines whose solutions can't be generated by a computer.
04:10:18 <korvo> I meant it is "cool as hell".
04:10:39 <MarkFan8901> wait we might have misinterpreted 'the hypothesis that godels theorem can be fully encoded'
04:11:00 <korvo> Like, obviously we can iterate all of the *candidate* solutions. But it's undecidable whether that iteration will ever give a *valid* solution.
04:11:44 <korvo> Oh, sorry! I meant that Robinson hoped that Gödelian reasoning applied to Diophantines. It would mean that Diophantines are just as strong as any other way of doing maths, in that they're too tough for computers.
04:12:31 <MarkFan8901> ya we thought you mean robinson hypothesized that godels theorem could be encoded in like a tangible math thing
04:12:45 <korvo> And then Matiyasevich gets credit for pointing out that a particular set fills the gap in a composite argument of Robinson, Davis, & Putnam. He put everybody together, and they published a bunch of papers giving independent perspectives.
04:14:32 <korvo> Putnam worked with Davis on a couple papers. Eventually all three of them, RDP, teamed up for a 1961 paper, according to my notes.
04:16:07 <MarkFan8901> we have another thing thats kinda annoying for us
04:16:17 <korvo> Sometimes it feels like that for coauthors. In this case, I think that they were a critical part of the rigor involved, and also in working towards Robinson's hypothesis. It's hard to see from our perspective, but one of Davis's conjectures was proven in 2008; if Matiyasevich never made their note then we'd say that Davis's conjecture was the important one!
04:17:35 <MarkFan8901> anyways we have this idea on how to avoid the whole passing instructions as arguments to other instructions thing
04:17:42 <korvo> Yeah, Robinson said "there is a JR set" (her initials, see wiki for precise definition) and Davis said "there are primes in arithmetic progression, as many as you like", which is TBH way more elegant.
04:18:26 <korvo> e.g. [3, 7, 11] is arithmetic progression with step of +4 and everybody's prime; Davis guessed there's no size limit on these.
04:18:37 <MarkFan8901> yes thats an incredibly elegant thing to say
04:18:37 <korvo> Sorry, tangent over, I'm listening.
04:18:52 <esolangs> [[YES WAY!]] https://esolangs.org/w/index.php?diff=190085&oldid=190084 * Miui * (+17)
04:20:19 -!- MarkFan9801 has joined.
04:21:38 <MarkFan9801> so the idea is to just define all input and output of an instruction as different cells from whatever different cuts
04:21:57 <MarkFan9801> ie you could say `add, main[0], main[1], main[2]`
04:22:21 <MarkFan9801> and that would add the contents of the first and second elements in main mem and store it in the third
04:22:31 <esolangs> [[User:Marcus 2n2]] M https://esolangs.org/w/index.php?diff=190086&oldid=189978 * Marcus 2n2 * (+87)
04:22:43 <MarkFan9801> or you could do `add, main[0], main[1], main[0]` for an x86 style of adding
04:22:56 <MarkFan9801> Or you could also do `add, main[0], main[1], some_other_cut[0]`
04:23:10 -!- MarkFan8901 has quit (Ping timeout: 247 seconds).
04:23:16 -!- MarkFan9801 has changed nick to MarkFan8901.
04:23:44 <MarkFan8901> the issue we had was we thought of something like `main[main[0]]`
04:24:26 <MarkFan8901> if we wanted to pull that off directly in machine code we would have to have some instruction that would correspond to pointer chasing
04:24:38 <MarkFan8901> ...which is the exact problem we were trying to solve
04:25:18 <MarkFan8901> instead, each argument is actually two different values
04:25:30 <MarkFan8901> one corresponding to the pointer of the cut and one to its position
04:26:36 <esolangs> [[User:Marcus 2n2]] M https://esolangs.org/w/index.php?diff=190087&oldid=190086 * Marcus 2n2 * (+60)
04:26:49 <MarkFan8901> then if you wanted to get values from other places you could just load them manually, then refer to them with that system
04:27:59 <MarkFan8901> oh yea another entertaining thought we had about compiling/interpreting
04:28:52 <MarkFan8901> when youre compiling, youre simply rewriting one representation of computation into another representation
04:28:54 <esolangs> [[52]] M https://esolangs.org/w/index.php?diff=190088&oldid=162670 * Marcus 2n2 * (+23)
04:29:06 <MarkFan8901> when youre interpreting, youre rewriting the representation of computation directly into the computation itself
04:30:00 <korvo> For that first thought: are y'all familiar with the idea of "first-class" and "second-class" syntax? I'm not super-fond of the terminology but it seems to be part of what's going on here.
04:30:54 <korvo> On that second thought, yes, compilers can be very simple in terms of computational complexity. There's actually a concept of "self-interpreter barrier", that certain weak systems can't interpret themselves, although it's a little outdated now.
04:31:23 <korvo> Okay, yeah. So, the quick idea is that a second-class value can't show up via some reference. It has to be syntactically spelled out every time.
04:32:09 <korvo> First-class values, like integer and string literals, can just be themselves or they can be assigned to variables which show up on their behalf.
04:32:32 <MarkFan8901> are integers and strings themselves second class
04:33:30 <korvo> Yeah, they would be.
04:33:52 <korvo> The idea is that the first-class values are the things we're manipulating with the machine. They're low-level. They're the real computational stuff.
04:34:59 <korvo> Second-class values are just structural annotations for humans who write programs. The machine doesn't really know what they are. (Or, in some perverse languages, the machine knows full well what they are and enjoys watching you type a lot of words; this is called a *high-ceremony* language and it's okay to (dis)like ceremony.)
04:36:02 <korvo> I think C macros are second class? People argue a lot about second-class parts of C. Folks used to say that arrays are second-class, because you can't just write an array literal in C without worrying about its storage or lifetime.
04:36:35 <MarkFan8901> doesnt that go for literally everything else that takes up memory in c
04:36:49 <korvo> So, like, don't just take anybody's word on this. It's a design concept, it's from the 1960s, people were really experimental back then.
04:37:23 <MarkFan8901> we imagine second class just means you cant work with it directly
04:37:40 <korvo> Oh! It's not about taking up memory but about what the language will let you express. Like, C won't let you do first-class manipulation of the *definitions* of structs, although you can do first-class byte inspection of structs.
04:37:55 <esolangs> [[Aheui]] https://esolangs.org/w/index.php?diff=190089&oldid=187155 * Miui * (-16) /* Collatz function */ remove "found by Gemini" (left in summary of edit for posterity)
04:39:06 <MarkFan8901> unrelated we looked at the wiki page for that "YES WAY!" esolang that kept getting edited during this convo
04:39:18 <MarkFan8901> > YES WAY! is a esolang where you play blue sphere to execute 3 instruction brainfuck and it writes deadfish to a text field which can queue inputs back to blue sphere!
04:39:19 <lambdabot> <hint>:1:23: error: parse error on input `where'
04:39:52 <MarkFan8901> Within Blue Sphere itself YES WAY! is able to go to the menu.
04:39:56 <korvo> Yeah, Miui's not really understanding the point of the wiki. I think most of their work is artlangs. Which is allowed, to be clear. The chatbot-generated pages are not okay but I don't think that they've read the rules.
04:40:19 <MarkFan8901> was that last sentence made by a markov chain or msth
04:41:24 <MarkFan8901> okay anyways why did you think first class and second class syntax was important here
04:43:27 <korvo> In a fragment like `main[main[0]]`, is it possible to reference `main[0]` first-class, or must it be second-class? Like, does the machine require an offset here? Some assembly languages do have that sort of thing, like the infamous x86 LEA instructions.
04:44:13 <korvo> Certainly `0` and `1` are first-class, guessing from the other fragments. Are those things that the machine can manipulate too, or are they constants for y'all the programmers?
04:44:16 -!- Guest97 has joined.
04:44:47 <MarkFan8901> the idea was that the value of `main[0]` would be passed to the outer `main[...]`
04:44:51 <korvo> I know my tone's not the best; again, I'm trying to open up options for exploration, not to demand answers right now.
04:45:15 <MarkFan8901> ur tone is completely natural to us if ur worried
04:46:12 <MarkFan8901> which wouldnt work cuz it leads us to the same problem we were trying to solve
04:46:21 <MarkFan8901> so we think it should be second class instead
04:50:46 <MarkFan8901> yea we think thats about all the talk in us for now
04:50:55 <MarkFan8901> thank you for helping us so much with this
04:51:05 <korvo> Hold up! Let me say one thing then.
04:51:05 -!- MarkFan8901 has quit (Remote host closed the connection).
04:51:21 <korvo> The fucking insight. The fucking point. Fuck.
04:52:02 <korvo> The point was that anything first-class has to be reified in the metainterpreter's theories. Every concept belongs to some theory somewhere, and the metainterp's gotta have a corresponding type or struct or something.
04:52:37 <korvo> I don't know why the fuck I bother. Clearly not helping anybody.
04:52:38 -!- Hooloovoo has quit (Server closed connection).
04:53:33 -!- Hooloovoo has joined.
05:05:58 -!- Guest97 has quit (Quit: Client closed).
05:06:26 -!- Lord_of_Life has quit (Quit: Laa shay'a waqi'un moutlaq bale kouloun moumkine).
05:07:59 -!- laerling has quit (Server closed connection).
05:08:10 -!- laerling has joined.
05:11:01 -!- Sgeo has quit (Read error: Connection reset by peer).
05:45:50 -!- Lord_of_Life has joined.
06:17:40 <esolangs> [[FlamePL]] N https://esolangs.org/w/index.php?oldid=190090 * PrySigneToFry * (+14470) Created page with "FlamePL is designed by PSTF and his AI assistant. = Overview = FlamePL is a programming language for data analysis and software developing. = Syntax = == Formal EBNF Grammar == <pre>(* Lexical tokens (terminals) *) letter = "A" | "B" | ... | "Z" | "a" | "b" .
06:18:01 <esolangs> [[FlamePL/Python Interpreter]] N https://esolangs.org/w/index.php?oldid=190091 * PrySigneToFry * (+37017) Created page with "<pre> import re import sys import math from decimal import Decimal, getcontext # Set high precision for arbitraryprecision floats getcontext().prec = 80 # ---------------------------------------------------------------------- # Data types #
06:18:54 <esolangs> [[Language list]] https://esolangs.org/w/index.php?diff=190092&oldid=189992 * PrySigneToFry * (+14)
06:29:54 <esolangs> [[-]] https://esolangs.org/w/index.php?diff=190093&oldid=189976 * Dragoneater67mobile * (+75) /* Optional extensions */ allow ignoring whitespaces
06:32:37 <esolangs> [[FlamePL]] M https://esolangs.org/w/index.php?diff=190094&oldid=190090 * Dragoneater67mobile * (+29) tag as slop
06:33:04 <esolangs> [[Ghmi-Asden Tnauin]] N https://esolangs.org/w/index.php?oldid=190095 * None1 * (+1933) Created page with "'''Ghmi-Asden Tnauin''' (or '''GAT''', anagram for "Anti-Human Design") is an esolang invented by [[User:None1]]. It's not made hard to program in, but made hard to use by humans. This esolang is user-edited and you can add features that make it even harder to u
06:38:07 <esolangs> [[GAT]] N https://esolangs.org/w/index.php?oldid=190096 * None1 * (+31) Redirected page to [[Ghmi-Asden Tnauin]]
06:42:41 -!- int-e has quit (Server closed connection).
06:42:52 -!- int-e has joined.
06:54:38 <esolangs> [[Language list]] https://esolangs.org/w/index.php?diff=190097&oldid=190092 * None1 * (+24) /* G */
06:54:59 <esolangs> [[Ghmi-Asden Tnauin]] https://esolangs.org/w/index.php?diff=190098&oldid=190095 * None1 * (-1) /* Rules */
06:55:13 <esolangs> [[Ghmi-Asden Tnauin]] https://esolangs.org/w/index.php?diff=190099&oldid=190098 * None1 * (+14) /* Features */
06:56:05 <esolangs> [[User:None1]] https://esolangs.org/w/index.php?diff=190100&oldid=189796 * None1 * (+66) /* My Esolangs */
06:56:27 -!- Lord_of_Life has quit (Quit: Laa shay'a waqi'un moutlaq bale kouloun moumkine).
06:57:28 <esolangs> [[Ghmi-Asden Tnauin]] M https://esolangs.org/w/index.php?diff=190101&oldid=190099 * None1 * (-2) /* Examples */
06:57:45 <esolangs> [[Ghmi-Asden Tnauin]] M https://esolangs.org/w/index.php?diff=190102&oldid=190101 * None1 * (+4) /* Features/Restrictions */
06:57:56 <esolangs> [[Ghmi-Asden Tnauin]] M https://esolangs.org/w/index.php?diff=190103&oldid=190102 * None1 * (-1) /* Features/Restrictions */
07:15:21 <esolangs> [[Ghmi-Asden Tnauin]] https://esolangs.org/w/index.php?diff=190104&oldid=190103 * Cleverxia * (+2525) made it even more confusing. this is just chaotic evil
07:16:40 <esolangs> [[ELVM]] https://esolangs.org/w/index.php?diff=190105&oldid=148214 * None1 * (-8) /* Internals */ Update according to newest spec, and fix grammar
07:18:43 <esolangs> [[Ghmi-Asden Tnauin]] M https://esolangs.org/w/index.php?diff=190106&oldid=190104 * None1 * (+106) /* Rules */
07:19:02 <esolangs> [[Ghmi-Asden Tnauin]] M https://esolangs.org/w/index.php?diff=190107&oldid=190106 * None1 * (+12) /* Rules */
07:22:33 <esolangs> [[]] https://esolangs.org/w/index.php?diff=190108&oldid=190032 * Cleverxia * (+247) the edit history suggests that 3angle made type 95
07:25:59 <esolangs> [[Odmu]] N https://esolangs.org/w/index.php?oldid=190109 * Klk bb * (+25) Redirected page to [[User:Klk bb]]
07:26:08 <esolangs> [[Odmu]] https://esolangs.org/w/index.php?diff=190110&oldid=190109 * Klk bb * (-25) Blanked the page
07:26:33 <esolangs> [[Esolang:Candidates for deletion]] https://esolangs.org/w/index.php?diff=190111&oldid=173708 * Klk bb * (+11)
07:26:38 <esolangs> [[Ghmi-Asden Tnauin]] M https://esolangs.org/w/index.php?diff=190112&oldid=190107 * None1 * (+0) /* Features/Restrictions */
07:27:37 -!- lisbeths has joined.
07:28:47 <esolangs> [[Ghmi-Asden Tnauin]] https://esolangs.org/w/index.php?diff=190113&oldid=190112 * Cleverxia * (+13) /* Features/Restrictions */
07:29:11 <esolangs> [[Ghmi-Asden Tnauin]] M https://esolangs.org/w/index.php?diff=190114&oldid=190113 * None1 * (+0) /* Features, restrictions, and twists */
07:30:37 <esolangs> [[Ghmi-Asden Tnauin]] https://esolangs.org/w/index.php?diff=190115&oldid=190114 * None1 * (+61) /* Rules */
07:34:06 -!- tromp has joined.
07:34:07 <esolangs> [[Ghmi-Asden Tnauin]] https://esolangs.org/w/index.php?diff=190116&oldid=190115 * Cleverxia * (+253) /* Features, restrictions, and twists */
07:37:30 <esolangs> [[Ghmi-Asden Tnauin]] M https://esolangs.org/w/index.php?diff=190117&oldid=190116 * None1 * (+2) /* Features, restrictions, and twists */ fix typo
07:37:54 <esolangs> [[Ghmi-Asden Tnauin]] M https://esolangs.org/w/index.php?diff=190118&oldid=190117 * None1 * (+0) /* Features, restrictions, and twists */
07:40:38 <esolangs> [[User talk:PrySigneToFry]] https://esolangs.org/w/index.php?diff=190119&oldid=189167 * None1 * (+361) /* I made a new user-edited esolang */ new section
07:40:48 <esolangs> [[User talk:PrySigneToFry]] M https://esolangs.org/w/index.php?diff=190120&oldid=190119 * None1 * (+0) /* I made a new user-edited esolang */
07:44:33 <esolangs> [[Talk:-]] https://esolangs.org/w/index.php?diff=190121&oldid=190079 * Blashyrkh * (-276) /* QUINE */ Shorter QUINE (4032 > 3756)
07:58:39 -!- Lord_of_Life has joined.
08:07:31 <esolangs> [[Ghmi-Asden Tnauin]] M https://esolangs.org/w/index.php?diff=190122&oldid=190118 * None1 * (+8) /* Features, restrictions, and twists */
08:09:05 -!- Lord_of_Life has quit (Quit: Laa shay'a waqi'un moutlaq bale kouloun moumkine).
08:09:31 -!- Lord_of_Life has joined.
08:14:01 -!- Lord_of_Life has quit (Ping timeout: 248 seconds).
08:14:41 -!- Lord_of_Life has joined.
08:22:41 <esolangs> [[]] https://esolangs.org/w/index.php?diff=190123&oldid=190108 * None1 * (+527) /* Type 103 */
08:23:25 <esolangs> [[]] M https://esolangs.org/w/index.php?diff=190124&oldid=190123 * None1 * (+1) /* Type 104 */
08:25:09 <esolangs> [[]] M https://esolangs.org/w/index.php?diff=190125&oldid=190124 * None1 * (+26)
08:37:15 <esolangs> [[]] M https://esolangs.org/w/index.php?diff=190126&oldid=190125 * Raiseafloppafan7741 * (+4) /* Uncomputable */ add Type 105 to list of uncomputable dialects
08:50:27 -!- gAy_Dragon has quit (Quit: ZNC - https://znc.in).
08:50:44 -!- A_Dragon has joined.
08:51:50 -!- A_Dragon has changed nick to gAy_Dragon.
08:56:47 <esolangs> [[]] https://esolangs.org/w/index.php?diff=190127&oldid=190126 * None1 * (+280) /* Type 105 */
08:57:27 <esolangs> [[]] M https://esolangs.org/w/index.php?diff=190128&oldid=190127 * None1 * (+4) /* Uncomputable */
08:58:53 <esolangs> [[]] https://esolangs.org/w/index.php?diff=190129&oldid=190128 * None1 * (+138) /* Type 97 */
09:00:24 <esolangs> [[]] M https://esolangs.org/w/index.php?diff=190130&oldid=190129 * None1 * (+3) /* Type 104 */
09:05:13 <esolangs> [[]] M https://esolangs.org/w/index.php?diff=190131&oldid=190130 * None1 * (+378) /* Type 78 */
09:05:51 <esolangs> [[Ghmi-Asden Tnauin]] M https://esolangs.org/w/index.php?diff=190132&oldid=190122 * None1 * (+0) /* Hello, World! */
09:06:42 <esolangs> [[]] M https://esolangs.org/w/index.php?diff=190133&oldid=190131 * None1 * (+0)
09:09:01 -!- chloetax has quit (Read error: Connection reset by peer).
09:09:02 -!- chloetax has joined.
09:12:24 <esolangs> [[]] M https://esolangs.org/w/index.php?diff=190134&oldid=190133 * None1 * (+0) /* Type 97 */
09:24:51 <esolangs> [[Template:CL]] N https://esolangs.org/w/index.php?oldid=190135 * None1 * (+60) Created page with "<code>[[Constant language|ConstantLanguage]]({{{1}}})</code>"
09:25:27 <esolangs> [[Nope.]] https://esolangs.org/w/index.php?diff=190136&oldid=188825 * None1 * (-24)
09:26:59 <esolangs> [[UCL]] N https://esolangs.org/w/index.php?oldid=190137 * None1 * (+374) Created page with ":{{Distingush/Confusion|UClang|UClang*}} '''UCL''' ('''U'''ncomputable '''C'''onstant '''L'''anguage) is an esolang invented by [[User:None1]]. Every program prints the [[wikipedia:Chaitin's constant]], so it's {{CL|C}} where C is the Chaitin's constant. [[Category:2026]] [[Ca
09:27:11 <esolangs> [[UCL]] M https://esolangs.org/w/index.php?diff=190138&oldid=190137 * None1 * (+1)
09:28:28 <esolangs> [[UCL]] https://esolangs.org/w/index.php?diff=190139&oldid=190138 * None1 * (+71)
09:28:49 <esolangs> [[Joke language list]] https://esolangs.org/w/index.php?diff=190140&oldid=190083 * None1 * (+52) /* General languages */
09:29:21 <esolangs> [[User:None1]] M https://esolangs.org/w/index.php?diff=190141&oldid=190100 * None1 * (+52) /* My Esolangs */ 2 esolangs a day!
09:30:08 <esolangs> [[CL]] N https://esolangs.org/w/index.php?oldid=190142 * None1 * (+31) Redirected page to [[Constant language]]
09:31:16 <esolangs> [[Template:QACL]] N https://esolangs.org/w/index.php?oldid=190143 * None1 * (+81) Created page with "<code>[[Constant_language#Quine avoidance|QuineAvoiding]]({{{1}}},{{{2}}})</code>"
09:33:59 <esolangs> [[]] M https://esolangs.org/w/index.php?diff=190144&oldid=190134 * None1 * (-1) /* Dialects created in 2025 */ Fix a number of typos
09:51:58 <esolangs> [[Ghmi-Asden Tnauin]] https://esolangs.org/w/index.php?diff=190145&oldid=190132 * Miui * (+31) /* Examples */ actual right-alignment
09:53:40 <esolangs> [[Talk:Kak]] https://esolangs.org/w/index.php?diff=190146&oldid=189783 * ChuckEsoteric08 * (+372) /* This is Turing complete! */
09:55:09 <esolangs> [[Ghmi-Asden Tnauin]] M https://esolangs.org/w/index.php?diff=190147&oldid=190145 * Miui * (+1) /* Examples */ to fix thing with cat
09:56:40 <esolangs> [[User:ChuckEsoteric08]] https://esolangs.org/w/index.php?diff=190148&oldid=189719 * ChuckEsoteric08 * (-382) /* Some notable languages without known computational class */ Kak is proven to be TC and I actually had written a proof before for a language similar to Mountain/Old before
10:00:23 -!- sprock has quit (Ping timeout: 247 seconds).
10:27:13 <esolangs> [[Ghmi-Asden Tnauin]] https://esolangs.org/w/index.php?diff=190149&oldid=190147 * Miui * (+49) /* Examples */ make it harder to read for humans
10:34:24 <esolangs> [[Ghmi-Asden Tnauin]] https://esolangs.org/w/index.php?diff=190150&oldid=190149 * Dragoneater67mobile * (-49) Undo revision [[Special:Diff/190149|190149]] by [[Special:Contributions/Miui|Miui]] ([[User talk:Miui|talk]]) revert vandalism
10:40:59 <esolangs> [[Talk:Ghmi-Asden Tnauin]] N https://esolangs.org/w/index.php?oldid=190151 * Miui * (+218) Created page with "wasnt vandalism :~( people keep saying that and it makes it harder to learn if i did something wrong and have communcation. and ais doesnt like me~~~~"
10:43:35 <esolangs> [[Ghmi-Asden Tnauin]] https://esolangs.org/w/index.php?diff=190152&oldid=190150 * Cleverxia * (-32) Miui, you vandal
10:45:39 <esolangs> [[Talk:Ghmi-Asden Tnauin]] https://esolangs.org/w/index.php?diff=190153&oldid=190151 * Cleverxia * (-218) If you believe this isn't a vandal go&talk to ais523
10:56:09 <esolangs> [[Talk:FlamePL]] N https://esolangs.org/w/index.php?oldid=190154 * Cleverxia * (+327) yet again
11:05:21 <esolangs> [[]] https://esolangs.org/w/index.php?diff=190155&oldid=187410 * Dragoneater67mobile * (-4) fix example
11:06:22 <esolangs> [[Talk:Ghmi-Asden Tnauin]] https://esolangs.org/w/index.php?diff=190156&oldid=190153 * Miui * (+117)
11:09:00 <esolangs> [[Talk:Ghmi-Asden Tnauin]] https://esolangs.org/w/index.php?diff=190157&oldid=190156 * Cleverxia * (+158)
11:10:44 <esolangs> [[Talk:Ghmi-Asden Tnauin]] https://esolangs.org/w/index.php?diff=190158&oldid=190157 * Miui * (+316)
11:18:10 <esolangs> [[Ghmi-Asden Tnauin]] https://esolangs.org/w/index.php?diff=190159&oldid=190152 * Miui * (+15) /* Rules */ wasnt new feature but was a more strict interpretation of a set feature.
11:20:17 <esolangs> [[Ghmi-Asden Tnauin]] https://esolangs.org/w/index.php?diff=190160&oldid=190159 * Miui * (+48) /* Features, restrictions, and twists */ ban myself
11:20:27 <esolangs> [[Talk:Ghmi-Asden Tnauin]] https://esolangs.org/w/index.php?diff=190161&oldid=190158 * Cleverxia * (+163)
11:21:43 <esolangs> [[42 (klk bb)]] N https://esolangs.org/w/index.php?oldid=190162 * Klk bb * (+724) Created page with "'''42''' ''(klk bb)'' is an [[esoteric programming language|esolang]] with only two possible commands. Its main purpose is to output either <code>42</code> or <code>0</code>. The language is intentionally very simple. The <code>.</code> command outputs the Answer to
11:22:28 <esolangs> [[User:Klk bb]] https://esolangs.org/w/index.php?diff=190163&oldid=190075 * Klk bb * (+20)
11:22:40 <esolangs> [[Talk:Ghmi-Asden Tnauin]] https://esolangs.org/w/index.php?diff=190164&oldid=190161 * None1 * (+476) This is clearly vandalism
11:23:25 <esolangs> [[Ghmi-Asden Tnauin]] M https://esolangs.org/w/index.php?diff=190165&oldid=190160 * None1 * (-63) This is clearly vandalism
11:24:09 <esolangs> [[Ghmi-Asden Tnauin]] https://esolangs.org/w/index.php?diff=190166&oldid=190165 * None1 * (+48) /* Rules */
11:24:41 <esolangs> [[Ghmi-Asden Tnauin]] M https://esolangs.org/w/index.php?diff=190167&oldid=190166 * None1 * (-1) /* Rules */
11:25:23 <esolangs> [[Talk:Ghmi-Asden Tnauin]] https://esolangs.org/w/index.php?diff=190168&oldid=190164 * Miui * (+363)
11:26:46 <esolangs> [[Talk:Ghmi-Asden Tnauin]] https://esolangs.org/w/index.php?diff=190169&oldid=190168 * None1 * (+457)
11:33:15 <esolangs> [[Ghmi-Asden Tnauin]] https://esolangs.org/w/index.php?diff=190170&oldid=190167 * PrySigneToFry * (+301)
11:34:10 <esolangs> [[Ghmi-Asden Tnauin]] https://esolangs.org/w/index.php?diff=190171&oldid=190170 * Cleverxia * (+363)
11:37:49 <esolangs> [[Talk:Ghmi-Asden Tnauin]] https://esolangs.org/w/index.php?diff=190172&oldid=190169 * Cleverxia * (+320)
11:37:54 <esolangs> [[Talk:FlamePL]] M https://esolangs.org/w/index.php?diff=190173&oldid=190154 * Ractangle * (+212)
11:42:30 <esolangs> [[Talk:FlamePL]] https://esolangs.org/w/index.php?diff=190174&oldid=190173 * PrySigneToFry * (+1220)
11:42:58 <esolangs> [[Ghmi-Asden Tnauin]] https://esolangs.org/w/index.php?diff=190175&oldid=190171 * Cleverxia * (+156) /* Features, restrictions, and twists */ only physcopaths can use print(). --[[ErrorFull]]
11:43:45 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
11:44:36 <esolangs> [[Talk:FlamePL]] https://esolangs.org/w/index.php?diff=190176&oldid=190174 * PrySigneToFry * (+252)
11:47:58 -!- Lymia has quit (Server closed connection).
11:48:01 <esolangs> [[Ghmi-Asden Tnauin]] M https://esolangs.org/w/index.php?diff=190177&oldid=190175 * Cleverxia * (+70) /* Features, restrictions, and twists */
11:48:12 -!- Lymia has joined.
11:50:36 <esolangs> [[Talk:FlamePL]] https://esolangs.org/w/index.php?diff=190178&oldid=190176 * PrySigneToFry * (-8)
11:56:02 <esolangs> [[Talk:FlamePL]] https://esolangs.org/w/index.php?diff=190179&oldid=190178 * PrySigneToFry * (+180)
12:06:01 <esolangs> [[Ghmi-Asden Tnauin]] M https://esolangs.org/w/index.php?diff=190180&oldid=190177 * None1 * (+3) /* Features, restrictions, and twists */ fix typo
12:08:39 <esolangs> [[Talk:Ghmi-Asden Tnauin]] https://esolangs.org/w/index.php?diff=190181&oldid=190172 * None1 * (+564) /* Restriction seem to contradict with the examples */ new section
12:12:46 <esolangs> [[Talk:Ghmi-Asden Tnauin]] M https://esolangs.org/w/index.php?diff=190182&oldid=190181 * None1 * (-5)
12:13:29 <esolangs> [[Talk:Ghmi-Asden Tnauin]] M https://esolangs.org/w/index.php?diff=190183&oldid=190182 * None1 * (+1) /* Restriction seem to contradict the examples */
12:13:39 <esolangs> [[Talk:FlamePL]] https://esolangs.org/w/index.php?diff=190184&oldid=190179 * Cleverxia * (+1138)
12:14:58 <esolangs> [[Talk:Ghmi-Asden Tnauin]] https://esolangs.org/w/index.php?diff=190185&oldid=190183 * Cleverxia * (+96) /* Restriction seems to contradict the examples */
12:15:24 <esolangs> [[Ghmi-Asden Tnauin]] https://esolangs.org/w/index.php?diff=190186&oldid=190180 * Cleverxia * (+13) /* Features, restrictions, and twists */
12:15:25 -!- amby has joined.
12:17:58 <esolangs> [[Mira]] N https://esolangs.org/w/index.php?oldid=190187 * Klk bb * (+546) Created page with "{{wip}} [[Mira]] is a small [[esoteric programming language]] and [[brainfuck]] derivative that removes half of Brainfuck's commands, replaces the remaining ones, and adds a couple of its own instructions. {| !Command!!description |- |||bf + then output ascii |- |||bf < |- |
12:18:30 <esolangs> [[Mira]] https://esolangs.org/w/index.php?diff=190188&oldid=190187 * Klk bb * (-4)
12:19:44 <esolangs> [[User:Klk bb]] https://esolangs.org/w/index.php?diff=190189&oldid=190163 * Klk bb * (+10)
12:23:34 <esolangs> [[ABCDirection]] https://esolangs.org/w/index.php?diff=190190&oldid=189072 * Bangyen * (-99) Undo revision [[Special:Diff/189072|189072]] by [[Special:Contributions/Bangyen|Bangyen]] ([[User talk:Bangyen|talk]])
12:33:28 <esolangs> [[Talk:UCL]] N https://esolangs.org/w/index.php?oldid=190191 * Corbin * (+350) Fix a misconception. What was the point of this page?
12:43:18 -!- somefan_ has joined.
12:44:58 <esolangs> [[ORK]] https://esolangs.org/w/index.php?diff=190192&oldid=188914 * None1 * (+9624) Add quine
12:45:13 <esolangs> [[ORK]] https://esolangs.org/w/index.php?diff=190193&oldid=190192 * None1 * (+18) /* Quine */
12:46:52 <esolangs> [[UCL]] https://esolangs.org/w/index.php?diff=190194&oldid=190139 * None1 * (+18)
12:47:14 <esolangs> [[Talk:UCL]] https://esolangs.org/w/index.php?diff=190195&oldid=190191 * None1 * (+283)
12:59:00 <korvo> ^^ Anybody computed Chaitin's constant for brainfuck? I think I'm getting nerd-sniped.
12:59:26 -!- somefan_ has quit (Remote host closed the connection).
13:02:22 -!- b_jonas has quit (Server closed connection).
13:02:35 -!- b_jonas has joined.
13:02:50 <esolangs> [[Ghmi-Asden Tnauin]] M https://esolangs.org/w/index.php?diff=190196&oldid=190186 * None1 * (+1) /* Features, restrictions, and twists */ not a typo
13:03:53 -!- tromp has joined.
13:04:42 <esolangs> [[Deadfish&]] N https://esolangs.org/w/index.php?oldid=190197 * Klk bb * (+527) Created page with "[[deadfish&]] is a combination of [[&]] and [[deadfish]]. That is, it is the same [[deadfish]], but it will not run if it exists. ==python interpreter== <pre> a = 0 try: a raise SyntaxError("This esolang exists") except NameError: a = 0 for c in input(
13:04:42 <esolangs> [[Talk:UCL]] https://esolangs.org/w/index.php?diff=190198&oldid=190195 * Blashyrkh * (+360) There's no single value for brainfuck. Brainfuck implementations are different
13:05:06 <esolangs> [[User:Klk bb]] https://esolangs.org/w/index.php?diff=190199&oldid=190189 * Klk bb * (+15)
13:06:59 <esolangs> [[?index.php]] https://esolangs.org/w/index.php?diff=190200&oldid=189824 * Dragoneater67mobile * (+3695)
13:07:23 -!- mosdfisdnfdisnf has quit (Ping timeout: 247 seconds).
13:07:46 <esolangs> [[User:Dragoneater67]] https://esolangs.org/w/index.php?diff=190201&oldid=189680 * Dragoneater67mobile * (+62)
13:17:52 <esolangs> [[?index.php]] M https://esolangs.org/w/index.php?diff=190202&oldid=190200 * Dragoneater67mobile * (-71) /* Overview */ remove duplicate entry
13:29:21 <esolangs> [[Ghmi-Asden Tnauin]] M https://esolangs.org/w/index.php?diff=190203&oldid=190196 * Cleverxia * (+41) /* Features, restrictions, and twists */ This esolang is nearly full
13:31:44 <esolangs> [[?index.php]] M https://esolangs.org/w/index.php?diff=190204&oldid=190202 * Dragoneater67mobile * (-1) fix typo
13:34:24 <esolangs> [[Talk:FlamePL]] https://esolangs.org/w/index.php?diff=190205&oldid=190184 * PrySigneToFry * (+6408)
13:39:47 <esolangs> [[Talk:FlamePL]] https://esolangs.org/w/index.php?diff=190206&oldid=190205 * PrySigneToFry * (+453)
13:41:32 <esolangs> [[User:PrySigneToFry]] https://esolangs.org/w/index.php?diff=190207&oldid=189107 * PrySigneToFry * (-51)
13:41:57 <esolangs> [[Ghmi-Asden Tnauin]] https://esolangs.org/w/index.php?diff=190208&oldid=190203 * None1 * (+551) Not yet
13:42:14 -!- duo_lepores has joined.
13:42:39 <esolangs> [[Ghmi-Asden Tnauin]] M https://esolangs.org/w/index.php?diff=190209&oldid=190208 * None1 * (+0) /* Features, restrictions, and twists */
13:43:20 <esolangs> [[Ghmi-Asden Tnauin]] M https://esolangs.org/w/index.php?diff=190210&oldid=190209 * None1 * (-1) /* Rules */
13:44:08 <esolangs> [[UCL]] M https://esolangs.org/w/index.php?diff=190211&oldid=190194 * None1 * (-1)
13:44:57 -!- hypha has quit (Server closed connection).
13:45:11 -!- hypha has joined.
13:46:02 -!- duo_lepores has quit (Client Quit).
13:48:48 <esolangs> [[Ghmi-Asden Tnauin]] M https://esolangs.org/w/index.php?diff=190212&oldid=190210 * None1 * (+2) /* Cat */
13:54:40 -!- duo_lepores has joined.
13:54:51 -!- duo_lepores has quit (Client Quit).
13:59:09 <esolangs> [[?index.php]] M https://esolangs.org/w/index.php?diff=190213&oldid=190204 * Dragoneater67mobile * (+7) who ate the string
14:08:01 <esolangs> [[Talk:FlamePL]] https://esolangs.org/w/index.php?diff=190214&oldid=190206 * Dragoneater67mobile * (+650) /* You've said enough, right? Fine, the counterattack starts now. */ ok
14:22:07 <esolangs> [[?index.php]] https://esolangs.org/w/index.php?diff=190215&oldid=190213 * Dragoneater67mobile * (+0) WHYYYYYY
14:44:51 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
15:11:28 -!- tromp has joined.
15:13:19 -!- kibty has quit (Read error: Connection reset by peer).
15:54:07 <esolangs> [[User:Hotcrystal0/Sandbox]] https://esolangs.org/w/index.php?diff=190216&oldid=189016 * Hotcrystal0 * (-464) cleanup of unnecessary content
15:54:41 <esolangs> [[User:Hotcrystal0/Sandbox]] https://esolangs.org/w/index.php?diff=190217&oldid=190216 * Hotcrystal0 * (+9)
15:57:49 <esolangs> [[User:Hotcrystal0/13]] https://esolangs.org/w/index.php?diff=190218&oldid=189733 * Hotcrystal0 * (-19)
16:04:29 <esolangs> [[CFUCK]] https://esolangs.org/w/index.php?diff=190219&oldid=135647 * Hotcrystal0 * (+33)
16:04:42 <esolangs> [[CFuck]] https://esolangs.org/w/index.php?diff=190220&oldid=118485 * Hotcrystal0 * (+33)
16:06:58 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
16:09:36 <esolangs> [[RuleLoader]] https://esolangs.org/w/index.php?diff=190221&oldid=182768 * Hotcrystal0 * (+8) Fix link
16:15:19 -!- Lord_of_Life has quit (Quit: Laa shay'a waqi'un moutlaq bale kouloun moumkine).
16:18:19 -!- Lord_of_Life has joined.
16:18:46 <esolangs> [[User:Hotcrystal0/Sandbox]] https://esolangs.org/w/index.php?diff=190222&oldid=190217 * PkmnQ * (+63) /* Number esolangs */ there's probably more but for now I only remember the two 99s
16:20:12 -!- tromp has joined.
16:26:04 <esolangs> [[Talk:2DChanger]] https://esolangs.org/w/index.php?diff=190223&oldid=184776 * ChuckEsoteric08 * (+5) /* TC proof sketch */
16:42:28 -!- rodgort has quit (Server closed connection).
16:44:46 -!- rodgort has joined.
17:03:08 <esolangs> [[User:Hotcrystal0/Sandbox]] M https://esolangs.org/w/index.php?diff=190224&oldid=190222 * Blashyrkh * (+28) /* Number esolangs */ 67s
17:14:42 <esolangs> [[User:Hotcrystal0/Sandbox]] https://esolangs.org/w/index.php?diff=190225&oldid=190224 * Hotcrystal0 * (+69)
17:28:47 -!- Lord_of_Life has quit (Quit: Laa shay'a waqi'un moutlaq bale kouloun moumkine).
17:30:32 <esolangs> [[User:Hotcrystal0/Sandbox]] https://esolangs.org/w/index.php?diff=190226&oldid=190225 * PkmnQ * (+190) /* Number esolangs */ how could I forget the yearlangs (and 256)
17:35:10 -!- Lord_of_Life has joined.
17:47:12 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
17:58:12 <esolangs> [[?index.php]] M https://esolangs.org/w/index.php?diff=190227&oldid=190215 * Dragoneater67mobile * (+30) i just realized that this is golfable
18:11:25 <esolangs> [[Esolang2026 topicality proposal]] N https://esolangs.org/w/index.php?oldid=190228 * Assembly * (+363) Created page with "'''Esolang2026 topicality proposal''' is a joke esolang made by [[User:Assembly]]. == Commands == === Funny commands === {{cd|explode(x)}} {{cd|variable_evilKumquat(x).exists?}} <s>{{cd|six_seven(x)}}</s> its 2026. Moved to the section below ==
18:11:48 <esolangs> [[Esolang2026 topicality proposal]] M https://esolangs.org/w/index.php?diff=190229&oldid=190228 * Assembly * (+4)
18:16:42 -!- tromp has joined.
18:19:32 <esolangs> [[User:Dragoneater67/Sandbox]] https://esolangs.org/w/index.php?diff=190230&oldid=189823 * Dragoneater67mobile * (+4)
18:19:47 <esolangs> [[User:Dragoneater67/Sandbox]] https://esolangs.org/w/index.php?diff=190231&oldid=190230 * Dragoneater67mobile * (+1)
18:20:01 <esolangs> [[User:Dragoneater67/Sandbox]] https://esolangs.org/w/index.php?diff=190232&oldid=190231 * Dragoneater67mobile * (+2)
18:20:30 <esolangs> [[User:Dragoneater67/Sandbox]] https://esolangs.org/w/index.php?diff=190233&oldid=190232 * Dragoneater67mobile * (-22)
18:26:18 <esolangs> [[Esolang2026 topicality proposal]] https://esolangs.org/w/index.php?diff=190234&oldid=190229 * Aadenboy * (+74) distinguish
18:26:25 <esolangs> [[Esolang2026 topicality proposal]] M https://esolangs.org/w/index.php?diff=190235&oldid=190234 * Aadenboy * (-4)
18:27:54 <esolangs> [[Talk:NO WAY? NO WAY!]] https://esolangs.org/w/index.php?diff=190236&oldid=189224 * Miui * (+177)
18:29:44 <esolangs> [[Immutable Brainfuck]] N https://esolangs.org/w/index.php?oldid=190237 * Rainwave * (+4085) New language!
18:30:02 <esolangs> [[Esolang2026 topicality proposal]] M https://esolangs.org/w/index.php?diff=190238&oldid=190235 * Aadenboy * (+4) really?
18:34:06 <esolangs> [[User:Rainwave]] https://esolangs.org/w/index.php?diff=190239&oldid=189570 * Rainwave * (+30) Added Immutable Brainfuck
18:35:36 <esolangs> [[Language list]] https://esolangs.org/w/index.php?diff=190240&oldid=190097 * Rainwave * (+26) Added Immutable Brainfuck
18:37:53 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
18:43:19 <esolangs> [[User:Klk bb]] M https://esolangs.org/w/index.php?diff=190241&oldid=190199 * Klk bb * (+1261)
18:45:20 -!- tromp has joined.
18:52:33 <esolangs> [[Special:Log/upload]] upload * Klk bb * uploaded "[[File:Arsenic.svg.webp]]"
18:55:51 <esolangs> [[Zip]] https://esolangs.org/w/index.php?diff=190243&oldid=190042 * KamilMalicki * (-29)
19:08:50 -!- kibty has joined.
19:12:52 -!- DOS_User_webchat has joined.
19:23:51 -!- DOS_User_webchat has quit (Quit: Client closed).
19:42:22 <esolangs> [[File talk:Arsenic.svg.webp]] N https://esolangs.org/w/index.php?oldid=190244 * Aadenboy * (+353) Created page with "seems to be taken from [[commons:File:Arsenic.svg]], which isn't public domain ~~~~"
19:53:07 <esolangs> [[User:Klk bb]] https://esolangs.org/w/index.php?diff=190245&oldid=190241 * Klk bb * (-1252)
19:54:04 <esolangs> [[Immutable Brainfuck]] https://esolangs.org/w/index.php?diff=190246&oldid=190237 * Rainwave * (+27) Just one more category
20:32:03 <esolangs> [[]] N https://esolangs.org/w/index.php?oldid=190247 * Klk bb * (+752) Created page with "{{wrongtitle|title= <nowiki>||</nowiki>}} ''(without nowiki tags that you see in the source code)'' <div style="float: right; margin: 0 0 10px 15px;"> __TOC__ </div> '''||''' is a joke programming language developed by [[User:Klk bb]] in 2026. It self-interprets any code other t
20:32:49 <esolangs> [[User:Klk bb]] https://esolangs.org/w/index.php?diff=190248&oldid=190245 * Klk bb * (+17)
20:42:48 <esolangs> [[User:Klk bb]] M https://esolangs.org/w/index.php?diff=190249&oldid=190248 * Klk bb * (+0)
20:43:24 <esolangs> [[User talk:Klk bb]] https://esolangs.org/w/index.php?diff=190250&oldid=189915 * Assembly * (+165) /* August 2026 */ new section
20:47:50 <esolangs> [[Assembly]] M https://esolangs.org/w/index.php?diff=190251&oldid=136097 * Assembly * (+14)
20:48:47 <esolangs> [[Assembly]] https://esolangs.org/w/index.php?diff=190252&oldid=190251 * Assembly * (+37)
20:49:03 <esolangs> [[Assembly]] M https://esolangs.org/w/index.php?diff=190253&oldid=190252 * Assembly * (+4)
20:49:19 <esolangs> [[]] https://esolangs.org/w/index.php?diff=190254&oldid=190247 * Aadenboy * (-108)
20:49:28 <esolangs> [[]] https://esolangs.org/w/index.php?diff=190255&oldid=190254 * Aadenboy * (+18) /* Commands */
20:59:30 <esolangs> [[]] N https://esolangs.org/w/index.php?oldid=190256 * Assembly * (+332) Created page with "''' (key)''' is an esolang created by [[User:Assembly]]. == Commands == None of the CJK text are real words. === Structuring the code === :''In short: = open, = close'' To structure the code, we need opening and closing parentheses to format C-shapes. ==== Example ==== <pre>
21:00:01 <esolangs> [[]] https://esolangs.org/w/index.php?diff=190257&oldid=190256 * Assembly * (+58)
21:01:58 <esolangs> [[]] M https://esolangs.org/w/index.php?diff=190258&oldid=190257 * Assembly * (+17) /* Commands */
21:08:07 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
21:11:32 -!- tromp has joined.
21:15:53 <esolangs> [[P]] https://esolangs.org/w/index.php?diff=190259&oldid=145384 * Miui * (+132) /* External resources */ pushin P
21:16:17 <esolangs> [[QACL]] N https://esolangs.org/w/index.php?oldid=190260 * Assembly * (+47) Redirected page to [[Constant language#Quine avoidance]]
21:16:27 <esolangs> [[P]] M https://esolangs.org/w/index.php?diff=190261&oldid=190259 * Aadenboy * (+24) restore cat
21:19:37 <esolangs> [[P]] https://esolangs.org/w/index.php?diff=190262&oldid=190261 * Miui * (+14) /* External resources */ fix link to interpreter
21:27:35 -!- zzo38 has quit (Server closed connection).
21:29:53 -!- zzo38 has joined.
21:35:37 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
21:47:31 -!- tromp has joined.