00:16:39 -!- Noisytoot has quit (Excess Flood).
00:17:04 -!- Noisytoot has joined.
00:59:52 <esolangs> [[Talk:Tip]] M https://esolangs.org/w/index.php?diff=157381&oldid=56661 * CreeperBomb * (+953)
01:03:27 <esolangs> [[User:I am islptng/SingleOperandAssembly]] https://esolangs.org/w/index.php?diff=157382&oldid=150961 * I am islptng * (+1750)
01:10:15 <esolangs> [[FCompiler/Headers]] N https://esolangs.org/w/index.php?oldid=157383 * I am islptng * (+26) Created page with "{{back|fCompiler}} {{WIP}}"
01:10:26 <esolangs> [[FCompiler]] https://esolangs.org/w/index.php?diff=157384&oldid=157326 * I am islptng * (+163)
01:24:18 -!- amby has quit (Quit: so long suckers! i rev up my motorcylce and create a huge cloud of smoke. when the cloud dissipates im lying completely dead on the pavement).
01:58:00 <esolangs> [[Topple]] https://esolangs.org/w/index.php?diff=157385&oldid=157377 * H33T33 * (+24) /* test */ new section
01:58:12 <esolangs> [[Topple]] https://esolangs.org/w/index.php?diff=157386&oldid=157385 * H33T33 * (-24) /* test */
04:06:49 -!- Noisytoot has quit (Remote host closed the connection).
04:07:23 -!- Noisytoot has joined.
04:12:11 -!- Noisytoot has quit (Remote host closed the connection).
04:12:36 -!- Noisytoot has joined.
04:20:25 -!- sprock has quit (Ping timeout: 276 seconds).
04:21:46 -!- sprock has joined.
04:26:40 -!- Noisytoot has quit (Remote host closed the connection).
04:27:38 -!- Noisytoot has joined.
04:35:58 -!- Noisytoot has quit (Remote host closed the connection).
04:36:47 -!- Noisytoot has joined.
06:32:16 -!- tromp has joined.
06:33:06 -!- tromp has quit (Read error: Connection reset by peer).
07:29:32 -!- Sgeo_ has quit (Read error: Connection reset by peer).
07:36:56 <esolangs> [[User talk:I am islptng]] M https://esolangs.org/w/index.php?diff=157387&oldid=157312 * I am islptng * (+70)
08:04:23 <esolangs> [[Anti-Machine language]] https://esolangs.org/w/index.php?diff=157388&oldid=157215 * JIT * (+66)
08:09:29 <esolangs> [[Anti-Machine language]] https://esolangs.org/w/index.php?diff=157389&oldid=157388 * JIT * (+59)
08:09:34 <esolangs> [[User talk:I am islptng]] https://esolangs.org/w/index.php?diff=157390&oldid=157387 * I am islptng * (+29) /* Maybe a good rule... */
08:40:45 -!- FreeFull has quit (Quit: Lost terminal).
08:55:30 <esolangs> [[FAGI]] https://esolangs.org/w/index.php?diff=157391&oldid=157356 * Lucaz37 * (+366)
10:26:28 -!- FreeFull has joined.
10:37:26 <esolangs> [[User:B jonas/List]] https://esolangs.org/w/index.php?diff=157392&oldid=151366 * B jonas * (+457)
11:12:27 -!- slavfox has quit (Quit: ZNC 1.8.2 - https://znc.in).
11:15:39 -!- slavfox has joined.
11:17:48 <esolangs> [[GML]] https://esolangs.org/w/index.php?diff=157393&oldid=122164 * B jonas * (+2554)
11:22:10 <esolangs> [[Concatenative calculus]] https://esolangs.org/w/index.php?diff=157394&oldid=156938 * B jonas * (+139) /* Languages */
12:01:27 -!- amby has joined.
12:48:16 <esolangs> [[Albuquerque challenge]] https://esolangs.org/w/index.php?diff=157395&oldid=157177 * I am islptng * (+181)
12:59:32 <esolangs> [[Special:Log/newusers]] create * Pjk * New user account
13:38:43 <esolangs> [[Topple]] https://esolangs.org/w/index.php?diff=157396&oldid=157386 * H33T33 * (-39)
13:40:42 <esolangs> [[Topple]] M https://esolangs.org/w/index.php?diff=157397&oldid=157396 * H33T33 * (+27)
13:54:02 <esolangs> [[SETANDCOUNT]] M https://esolangs.org/w/index.php?diff=157398&oldid=155200 * Cycwin * (+58) /* Interpreter */
13:56:03 -!- Noisytoot has quit (Remote host closed the connection).
13:57:00 -!- Noisytoot has joined.
14:00:56 -!- Noisytoot has quit (Remote host closed the connection).
14:01:37 -!- Noisytoot has joined.
15:08:35 -!- Sgeo has joined.
16:55:38 <b_jonas> I have a question. I just tried to describe at https://esolangs.org/wiki/GML#Concatenative_calculus_as_a_special_case that there's this very simple subset of GML that implements concatenative (stack-based) calculus. All you need is lexically local bindings that you can load and push, or pop and bind to a new one, abstraction braces that create a new closure with the given body but saves the upvalues
16:55:44 <b_jonas> from the current environment in the closure (this is set!less so it doesn't matter if you save them by reference like scheme does or by value) and pushes that closure, and an apply operation that pops a closure and calls it. The trick is that functions don't take an argument like in lambda calculus, but instead share the stack with their callers.
16:58:32 <b_jonas> I find this interesting because it seems like concatenative calculus was first published in 2001, while GML was first published in 2000. I want to be careful so I don't want to claim that GML pre-invented concatenative calculus. I know it's often hard to notice that there's a small powerful core language hidden inside your language if you only keep a few parts of it. This has happened to me with
16:58:38 <b_jonas> Consumer Society, where it took me about half a year after I started to think about it just how few parts the language needs to keep. And IIUC for Underload it took even more time to find them in a larger language.
17:00:44 <b_jonas> So what I'd like to know is, what's the earliest precursor for this combination to appear, the closures with lexically local bindings but stack-based? I don't know if something close enough to Joy was known before 2001, I'm new to this whole history. While GML as such obviously wasn't published before 2000, it is likely based on some previous languages, and some of them might be similar.
17:02:23 <b_jonas> To be clear, GML is larger than this core language: Joy is like lambda calculus is that every value is a function and the only thing you can do with a function is call it, whereas GML has the square brackets which let you distinguish a mark value on the stack from functions.
17:04:38 <b_jonas> The stack clearly existed before, PostScript has a similar stack and is clearly older. And lexically local bindings in closures also clearly existed before, such as in scheme.
17:06:59 <b_jonas> Or in lambda calculus for that matter. Both lambda calculus and postscript are in what counts as the prehistory of esolangs here.
17:07:54 <esolangs> [[Topple]] https://esolangs.org/w/index.php?diff=157399&oldid=157397 * H33T33 * (+29)
17:13:12 <korvo> b_jonas: I was actually going to ping you about this earlier. So, I don't know exactly when quotations came about; https://concatenative.org/wiki/view/Quotations says PostScript has them, and that'd be a good missing link between Forth and Factor.
17:14:19 <korvo> But everything aside from quotations is straight out of category theory and abstract algebra; they're from universal properties that are so common that mathematicians have started naming them. The main thing that computer scientists added was stack-based evaluation semantics, later justified by realizing that certain categories are (equivalent to) certain lambda calculi.
17:15:29 <korvo> I think that it might be good to start the page, "Kerby's concatenative calculus is ..." given the context you've documented.
17:20:07 -!- chiselfuse has quit (Remote host closed the connection).
17:44:05 <b_jonas> korvo: postscript is relevant, it's not quite clear to me how naturally you could simulate this core language in postscript. there's also the inconvenience that running such code would probably have to heap-allocate a lot of objects, so in practice you could only run it in a non-old postscript interpreter so as to automatically free those objects with reference counting or some other garbage collection
17:44:11 <b_jonas> mechanism built into the postscript interpreter. but I think suitable garbage collection was of course already known at the time for lisps, they just hadn't put it into the postscript interpreters because it was supposed to run on cheap hardware.
17:44:42 <b_jonas> I don't understand the category theory part, or how Cammy is connected
17:47:14 <b_jonas> I think you may be using use postscript square brackets to create the closures like the GML square bracket, because that lets you save a reference to the upvalue everywhere a variable is referenced. and I think you can use dynamic local postscript bindings to reference variables that are bound at the same level, though I'm not sure which level of postscript you need for that
17:57:22 <korvo> The category theory is not hard, but it is kind of a mind-melter. Von Thun put it best: the syntax has a monoid, and the semantics that we intend to use also has a monoid. We just choose the monoid with unit "" and concatenation `++` because that's easy to think about.
17:58:04 <korvo> Except, uh, that monoid doesn't work for Joy. It works for Brainfuck! But Joy, Factor, etc. need to add whitespace. So clearly we're okay with syntactic monoids that add some extra characters.
17:59:09 <korvo> Cammy's monoid has unit `"id"` and concatenation `"(comp " + " ".join(args) + ")"`. Like in Joy, it's technically monoidoid, because the types need to line up.
17:59:28 <korvo> And then there's a relevant category-theory slogan: a monoidoid is a category.
17:59:33 <b_jonas> why is whitespace a problem? whitespace is a no-op, and there will be other no-op functions anyway
18:00:12 <korvo> Whitespace puts a lie to the idea that juxtaposition is how we concatenate the syntax. Like, given Joy programs "drop" and "dup", the concatenation would be "dropdup" but we actually want "drop dup".
18:00:46 <b_jonas> ok, then use strings (or even trees) of tokens instead of strings of characters
18:03:55 <korvo> That would be a semantics. Any kind of interpretation, even abstract syntax, would be a mapping. What we want is for every such mapping to be a monoid homomorphism, because then we can compose the mappings and always preserve this idea of juxtaposition leading to composition.
18:05:20 <b_jonas> sure, but at least a token list is just the easy part of semantics, one which we call syntax.
18:06:59 <korvo> I know. I'm merely trying to get across what Von Thun was seeing. It's not about parsing or stacks. It's about the idea that we can run one program after another, and what it means for the syntax to reflect that.
18:10:12 <korvo> b_jonas: Could I at least convince you that some languages *don't* have this nice property? Like, there are some languages s.t. there's *no* fixed syntax which will compose two arbitrary input programs (assuming their types already line up).
18:11:18 <korvo> Most industrial-usage serious-business languages fail this just because of how their compilers are defined. I suppose Java might be one of the exceptions.
18:26:20 <b_jonas> korvo: sure, it helps that Joy is concatenative
18:28:00 <b_jonas> hold on, this reminds me of something, let me find the reference
18:28:38 <korvo> b_jonas: Oh! Okay, so I think I get it. There's a really common meme in the catlang community: juxtaposition is composition. This is used to gatekeep; if the monoid isn't literally "" and ++ then it's not a catlang.
18:29:08 <korvo> And I'm just pointing out that this is reductive because obviously Joy's syntactic monoid requires whitespace too. It's a *fixed* whitespace, so everything still works, but it's not like Brainfuck.
18:30:00 <korvo> Also, like, juxtaposition is composition in Brainfuck but nobody seems to actually point this out. It's like a catlang has to have some specific heritage or it doesn't count, and I don't really like that treatment of what should be a mathematical property.
18:32:25 <b_jonas> http://www.madore.org/cgi-bin/comment.pl/showcomments?href=http%3a%2f%2fwww.madore.org%2f~david%2fweblog%2f2015-04.html%23d.2015-04-24.2292#comment-21587 explains that not only the movements on the Rubik's cube form a group, but something stronger is true: the visible states of the Rubik's cube (the information that's preserved if you take a color photo of all sides) forms a group, and this latter is
18:32:31 <b_jonas> not true for the 4×4×4 rubik's cube.
18:33:22 <b_jonas> I think a concatenative language is something that has a simple structure like this, where it's easy to see the whole state of the runtime, and that state forms a group with composing programs
18:33:32 <korvo> Ah, yeah. Cayley's theorem is a powerful intuition.
18:33:52 <korvo> Well, a monoid, not a group. Not every action is invertible.
18:35:39 <b_jonas> but I don't think the whitespace is a problem here, you can consider Joy concatenative even if you need to add a space between when you concatenate two programs. it's like you're building one of those super-fast rubik cube solving robots (there's way too many of them) and they have to wait a little between every too moves otherwise something in the machine+cube may break
18:35:44 <korvo> So, in that sense, Cammy is provably such a language. Cammy is what we call "initial in a certain category"; among everything with that property, Cammy always can be mapped into that thing.
18:36:21 <korvo> Brainfuck is also an example. The state of the machine is what you'd expect: the cells, the pointer, the input and output.
18:37:47 <korvo> Sure, the whitespace is acceptable. But for something like Malbolge or Bubblegum, there might not be a single fixed string template which glues together two input programs, even if their underlying VMs can do it.
18:39:32 <korvo> Reminded of my phrasing at https://esolangs.org/wiki/Esolang_talk:Categorization#Monoids "By the folklore of concatenative languages, ... all of the concatenative and tacit languages would go in [a category for monoidal languages]."
18:42:41 <b_jonas> btw considering Joy a string of tokens works because all the questions that I asked still apply in interpretation, the representation with characters doesn't matter much
18:43:14 <b_jonas> (I might care about the concrete syntax for aesthetics of course)
18:45:35 <korvo> Yeah. But this also happens when the language wasn't designed for it. Application is composition (another fun slogan), so Unlambda has a monoidoid. IIRC the unit is "i" and composition is "`c" + p + q.
18:50:42 <korvo> b_jonas: Sorry if I'm being pushy about this. I just really want to avoid having three different articles about the same topic that have slightly different perspectives on the fundamentals.
18:51:48 <korvo> Also https://concatenative.org/wiki/view/Concatenative%20language says stuff like "In an applicative language, things are evaluated by applying functions to arguments. In a concatenative programming language, things are evaluated by composing several functions which all operate on a piece of data." Categorically, those are the *same thing*.
18:52:55 <korvo> (Because in a category an "argument" or "element" is just a special case of a function!)
18:54:17 -!- ais523 has joined.
18:54:32 <ais523> I think BF only forms a monoid if you ignore the rule that the tape starts as all-zeroes
18:55:04 <ais523> because if you are composing two programs, rather than two program fragments, don't you have to zero the tape in between?
18:56:13 <ais523> for the composition to work, you have to generalise BF programs into BF subroutines (i.e. capable of taking input from the tape)
18:57:50 <korvo> Monoidoids are acceptable; Joy's composition is only defined when the types line up, and Factor also has stack-checking.
18:58:34 <korvo> It is not a problem to think of a BF program as having a type which indicates how its tape should be aligned (say, in the world where BF tapes don't loop!) and then requiring alignment in order to concatenate.
19:03:07 <korvo> ais523: Oh! The tape itself having all zeroes! Yeah, we're not doing Kolmogorov complexity. What we're getting at is the idea that a compiler is a homomorphism: a compiler can be defined in terms of the structure of the input language and will preserve that structure in its output.
19:03:54 <korvo> Lists are free monoids, so any time a compiler is storing something in a list, it's probably manipulating a monoid. Peephole specializers exhibit non-trivial monoids, for example.
19:05:52 * korvo trying not to be flowery
19:07:30 <korvo> The compiler might have to emit a prologue, epilogue, or harness. But the guts of the compiler, like some generic optimizer that operates on hunks of code, can still respect the monoid.
19:09:56 <korvo> ais523: Okay, actually, let's go with that route and consider a basic-block compiler. It usually will have a monoid which it uses to split blocks into pieces that don't interact with each other.
19:10:54 <korvo> And that's because there's a monoid. Given two basic blocks, we can merge them s.t. we take in all of the inputs, do all of the operations without any overlapping, and return all of the outputs. The unit is a do-nothing block with no inputs or outputs.
19:11:45 <korvo> *usually will have a pass, rather. The pass exhibits the monoid.
19:15:18 <esolangs> [[Candrabindu]] https://esolangs.org/w/index.php?diff=157400&oldid=157366 * * (+361)
19:20:15 <esolangs> [[]] N https://esolangs.org/w/index.php?oldid=157401 * * (+1416) Moved this page over from Candrabindu.
19:21:05 <esolangs> [[Candrabindu]] https://esolangs.org/w/index.php?diff=157402&oldid=157400 * * (-1396) Redirected page to [[]]
19:27:23 <korvo> I gotta stop going on rants right when Europe wants to go to bed. Sorry, I'll be around later too.
19:27:41 <ais523> I believed "lists are free monoids" for ages, but think it's actually wrong: you can have an empty list as a list element
19:28:29 <ais523> free monoids are like lists, but they automatically flatten
19:29:11 -!- impomatic has joined.
19:29:34 <korvo> Well, those are lists of lists. Different types.
19:30:40 <ais523> fwiw, I was wondering whether Rust functions F and G compose syntactically as (|x|{({\nF})(({\nG})(x))}) – I'm not quite sure whether Rust's identifier hygiene is up to it but it might be
19:30:57 <ais523> err, newline after F and G, not before, in case there's an unterminated line comment
19:32:05 <korvo> Probably, as long as stack behavior isn't a problem. In OCaml, that approach doesn't work, and it's why I had to port Cammy away from OCaml and to CHICKEN Scheme.
19:32:07 <ais523> Rust is very permissive with allowing things inside blocks that most languages only allow at top level, which is what makes me think it might actually work, but there's probably an obvious counterexample I'm missing
19:32:44 <ais523> type inference seems like it might be the largest problem, but if G forces a type on its argument, I think this will force the same type on its argument, and there are no other type inference problems
19:35:49 <korvo> Trying to remember whether `|x|{x}` can infer a general type. Like, can that be an &mut?
19:36:18 <ais523> yes, can be anything apart from an unsized type I think
19:38:08 <ais523> https://play.rust-lang.org/?version=stable&mode=debug&edition=2024&code=fn+main%28%29+%7B%0A++++let+mut+a+%3D+%5B1u32%2C+2%2C+3%5D%3B%0A++++%28%7Cx%7C%7Bx%7D%29%28%26mut+a%29%3B%0A++++%28%7Cx%7C%7Bx%7D%29%28a%5B..%5D%29%3B%0A%7D
19:38:19 <ais523> &mut works, unsized types don't
19:38:58 <ais523> anyway, even though I'll probably be awake for a while, the shops will be closing and I need to go shopping
19:39:02 -!- ais523 has quit (Quit: quit).
19:53:57 -!- impomatic has quit (Quit: Client closed).
20:05:33 -!- chiselfuse has joined.
20:35:21 <esolangs> [[User:Brain Boy 53]] https://esolangs.org/w/index.php?diff=157403&oldid=150115 * Brain Boy 53 * (+1)
20:35:43 <esolangs> [[User:Brain Boy 53]] https://esolangs.org/w/index.php?diff=157404&oldid=157403 * Brain Boy 53 * (+0)
20:50:18 <fizzie> Huh. Turns out fungot might have a Gmail account that I wasn't aware of.
20:50:19 <fungot> fizzie: that zippy appears to be an infinite-dimensional space, isn't it?)
20:51:04 <fizzie> I got a "your Google Account has not been used in at least 8 months" email, and searching for that in my email archives, there's a 2010 Gmail invite (I guess you needed one at the time to open an account), so maybe I (or fungot acting independently?) made one.
20:51:05 <fungot> fizzie: e.g. when using separate files, then run it check if the ending of a string is not empty
21:07:02 <esolangs> [[NoError]] https://esolangs.org/w/index.php?diff=157405&oldid=150116 * Brain Boy 53 * (+56)
21:32:42 <esolangs> [[Arbitrary memory emulation]] https://esolangs.org/w/index.php?diff=157406&oldid=157148 * Aadenboy * (+16)
21:38:05 -!- ais523 has joined.
22:11:09 <esolangs> [[User:Buckets]] M https://esolangs.org/w/index.php?diff=157407&oldid=157371 * Buckets * (+22)
22:11:21 <esolangs> [[User:Buckets/OMC]] N https://esolangs.org/w/index.php?oldid=157408 * Buckets * (+1729) Created page with "OMC stands for Other Mathematical Concepts. Core Sequence: 0,1,13... Have n Uniquely different items, The number for the core Sequence Is the longest Sequence as a number, The Sequence only has to follow 2 rules: # There Cannot be A sequence where the Same
22:23:30 <zzo38> Is there TLS library that you can mostly just change send to TLS_send and recv to TLS_recv in most of the program, that it can work with unencrypted connections as well? I also want to do my own handling of certificates (so the callback function only needs to extract the public key, or do nothing if the callback function decides that the certificate should not be used)
22:41:45 -!- Lord_of_Life has quit (Ping timeout: 244 seconds).
22:42:08 -!- Lord_of_Life has joined.
22:55:16 <esolangs> [[Talk:Anti-Machine language]] https://esolangs.org/w/index.php?diff=157409&oldid=124048 * Stkptr * (+318) /* What counts as a machine? */ new section
22:59:33 <esolangs> [[Concatenative calculus]] https://esolangs.org/w/index.php?diff=157410&oldid=157394 * Stkptr * (-45) /* Languages */ "syntactical monoid" is profoundly verbose for no benefit to the reader
23:01:28 <esolangs> [[User talk:TenBillionPlusOne]] https://esolangs.org/w/index.php?diff=157411&oldid=157378 * Hotcrystal0 * (+269)
23:20:04 -!- alec3660 has quit (Remote host closed the connection).
23:20:13 -!- alec3660 has joined.
23:20:20 -!- alec3660 has quit (Client Quit).
23:27:50 <esolangs> [[User:Buckets/OMC]] M https://esolangs.org/w/index.php?diff=157412&oldid=157408 * Buckets * (+3)
23:42:52 -!- nitrix has quit (Ping timeout: 265 seconds).