00:00:25 [[Lythnology]] M https://esolangs.org/w/index.php?diff=152726&oldid=152485 * RainbowDash * (+5) /* Creating Words */ 00:03:43 -!- mtm has quit (Ping timeout: 245 seconds). 00:05:58 -!- mtm has joined. 00:08:41 -!- 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). 00:35:10 [[Joke language list]] https://esolangs.org/w/index.php?diff=152727&oldid=152651 * Juanp32 * (+72) /* Brainfuck derivatives */ 01:06:00 -!- CanisCorvus has quit (Quit: Client closed). 03:08:16 -!- Lykaina has joined. 03:10:11 anyone here know who Hakerh400 is on the wiki? 03:15:18 [[User talk:Hakerh400]] https://esolangs.org/w/index.php?diff=152728&oldid=119857 * Lykaina * (+208) /* Afth Language */ new section 03:16:13 left them a message 03:28:25 -!- tromp has joined. 03:28:36 -!- tromp has quit (Client Quit). 03:42:13 Basically, they made an Afth interpreter and linked it to the wiki. I don't know Haskell. 03:44:33 so i offered assistance in implementing the language. 04:20:14 [[Fish]] https://esolangs.org/w/index.php?diff=152729&oldid=152693 * PrySigneToFry * (+573) 04:21:13 Lykaina: I don't think I can answer that question in a helpful way. What's the problem? 04:21:34 none 04:22:04 i was wondering if someone here used that username on the wiki 04:22:11 wanted to say hi 04:26:23 Ah, okay. I haven't seen them in IRC, sorry. 04:27:42 They write lots of interpreters for languages that interest them. I can empathize, because I do that too. 04:36:56 wanted to offer help with, for example, ensuring compatibility. 04:39:27 Lykaina: you can try to ask in the two discord groups 04:39:37 or just leave a message on the esowiki 04:40:23 b_jonas: sent email and left message on their talk page 04:40:37 There's two Discord guilds now? I guess they had more fallout drama. 04:42:55 i didn't know there were any 04:45:32 there's been two for ages I think 04:46:09 korvo: https://esolangs.org/wiki/Esolang:Community_portal#Other_real-time_discussion_communities lists three 04:46:53 Oh, and I had thought that we didn't endorse any of them. But I guess I'm wrong about that? 04:48:39 I wonder when multiple Reddit guilds will pop up too 04:49:17 I'm not sure mentioning their existence is necessarily an endorsement, and it's hard to argue it's offtopic (even though I dislike suggesting the use of Discord for anything) 04:49:32 korvo: this channel is full of bots yet there's no bridge from any of the Discord guilds to here, so I think that counts as not endorsing them 04:50:11 I assume there's a reason why they haven't merged 04:51:50 I don't think I've ever seen Discord communities merge. they just keep splitting. even though Discord is built in a way where individual users can hide or show groups of channels within a guild, so the infrastructure is supposed to support users with different but somewhat overlapping interests within a guild. 04:51:52 Sure. I had just recalled that there was some drama that led to the wiki disavowing the Discord guild. But maybe that was a different community. It's hard to keep track of Discord drama. 05:02:30 [[User talk:BrainFuckGirl]] https://esolangs.org/w/index.php?diff=152730&oldid=152714 * MihaiEso * (+360) 05:14:00 [[Esolang:Sandbox]] https://esolangs.org/w/index.php?diff=152731&oldid=152712 * MihaiEso * (+98) 05:19:39 [[User:MihaiEso/Targets]] https://esolangs.org/w/index.php?diff=152732&oldid=141957 * MihaiEso * (-62) 05:21:11 [[Fsx]] N https://esolangs.org/w/index.php?oldid=152733 * SerialDesignationF * (+798) Created page with "Fsx (F=) esolang: '''About:''' Fsx is a esolang made by F with some Murder Drones related stuff in it. '''Instructions: Category Function (f):''' |j (): if |n (): else |v: while '''Category Input (j):''' |: input | (): input with p 05:21:50 [[Fsx]] M https://esolangs.org/w/index.php?diff=152734&oldid=152733 * SerialDesignationF * (+12) 05:22:08 [[Fsx]] https://esolangs.org/w/index.php?diff=152735&oldid=152734 * SerialDesignationF * (-12) 05:22:21 [[Fsx]] https://esolangs.org/w/index.php?diff=152736&oldid=152735 * SerialDesignationF * (+1) 05:27:01 [[Fsx]] https://esolangs.org/w/index.php?diff=152737&oldid=152736 * SerialDesignationF * (+2) 05:32:57 [[Template:NewUserPage]] N https://esolangs.org/w/index.php?oldid=152738 * MihaiEso * (+146) Created page with "This is user {{{1}}}. You are allowed to replace all of this with your own content. Say like a long "Hello!" message and list your esolangs here." 05:33:25 [[User:SerialDesignationF]] N https://esolangs.org/w/index.php?oldid=152739 * MihaiEso * (+34) Created page with "{{NewUserPage|SerialDesignationF}}" 05:42:35 -!- Lykaina has quit (Quit: Leaving). 06:44:01 [[Pointing]] M https://esolangs.org/w/index.php?diff=152740&oldid=152681 * Calculus is fun * (+37) /* brainfuck interpreter */ 06:45:55 [[Pointing]] https://esolangs.org/w/index.php?diff=152741&oldid=152740 * Calculus is fun * (+101) Added fread 06:55:54 [[User:MihaiEso/InDev]] https://esolangs.org/w/index.php?diff=152742&oldid=136768 * MihaiEso * (+1969) 07:06:56 [[Template:WIPshort]] N https://esolangs.org/w/index.php?oldid=152743 * MihaiEso * (+49) Created page with "''This is a work in progress, expect more soon.''" 07:07:49 [[Template:WIPshort]] https://esolangs.org/w/index.php?diff=152744&oldid=152743 * MihaiEso * (+113) 07:08:14 [[Pointing]] https://esolangs.org/w/index.php?diff=152745&oldid=152741 * MihaiEso * (-38) 07:09:08 -!- Lord_of_Life has quit (Ping timeout: 245 seconds). 07:09:59 -!- Lord_of_Life has joined. 07:15:26 -!- tromp has joined. 07:24:47 [[Skript+]] N https://esolangs.org/w/index.php?oldid=152746 * MihaiEso * (+701) Created page with "'''Skript+''' is (or was) a esolang by Mihai Popa. == Overview == I know that the first "Hello, world!" example is working on ChatGPT. I'm here to move all of it from Wikibooks to Esolang. After somebody deleted the book from Wikibooks, only a bit of it exists. == 07:25:38 [[Skript+]] https://esolangs.org/w/index.php?diff=152747&oldid=152746 * MihaiEso * (+63) 07:26:22 [[User:MihaiEso]] https://esolangs.org/w/index.php?diff=152748&oldid=152670 * MihaiEso * (+72) 07:27:15 [[Language list]] https://esolangs.org/w/index.php?diff=152749&oldid=152644 * MihaiEso * (+14) /* S */ 08:16:42 [[Pointing]] https://esolangs.org/w/index.php?diff=152750&oldid=152745 * Calculus is fun * (+164) Instruction shuffle 08:18:00 [[Pointing]] M https://esolangs.org/w/index.php?diff=152751&oldid=152750 * Calculus is fun * (+1) /* Custom functions */ 08:19:42 [[Mutzerium]] N https://esolangs.org/w/index.php?oldid=152752 * PrySigneToFry * (+4970) Created page with "Mutzerium is designed by PSTF in OTL Universe, which is inspired from SLet 3.0(Currently, SLet is using 4.0 version). In PsiLine Universe, it is designed by Yang Jiong. = Language Overview = Mutzerium is Turing-Complete, almost-high-level, and uses easy syntax 08:20:37 [[Language list]] https://esolangs.org/w/index.php?diff=152753&oldid=152749 * PrySigneToFry * (+16) 08:30:16 -!- Sgeo_ has quit (Read error: Connection reset by peer). 08:33:29 [[Pointing]] M https://esolangs.org/w/index.php?diff=152754&oldid=152751 * Calculus is fun * (+23) /* Expressions */ 08:34:34 [[Special:Log/newusers]] create * 2ro * New user account 08:43:04 [[Esolang:Introduce yourself]] https://esolangs.org/w/index.php?diff=152755&oldid=152702 * 2ro * (+178) /* Introductions */ 08:43:43 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…). 08:54:44 [[Pointing]] https://esolangs.org/w/index.php?diff=152756&oldid=152754 * Calculus is fun * (+499) Short circuit example 09:05:42 [[Mutzerium]] https://esolangs.org/w/index.php?diff=152757&oldid=152752 * I am islptng * (+77) i wonder what is PsiLine universe;;; This is too close to SLet, but WHERE IS YOUR INTERPRETER! 09:07:25 [[Template:WIPshort]] https://esolangs.org/w/index.php?diff=152758&oldid=152744 * Ractangle * (-47) 09:22:53 -!- ais523 has quit (Quit: quit). 09:27:41 [[Mutzerium]] M https://esolangs.org/w/index.php?diff=152759&oldid=152757 * I am islptng * (+99) Make use of the fraction! GCD is simple! 09:27:55 [[User talk:Orby]] https://esolangs.org/w/index.php?diff=152760&oldid=78101 * 2ro * (+136) 09:34:05 [[Fsx]] https://esolangs.org/w/index.php?diff=152761&oldid=152737 * I am islptng * (+34) fix 09:36:11 -!- Noisytoot has quit (Quit: ZNC 1.9.1 - https://znc.in). 09:37:37 -!- Noisytoot has joined. 09:41:33 [[User talk:MihaiEso]] https://esolangs.org/w/index.php?diff=152762&oldid=152683 * I am islptng * (+581) /* UserEdited */ 09:47:19 -!- tromp has joined. 09:52:14 [[User:Orby]] https://esolangs.org/w/index.php?diff=152763&oldid=131402 * 2ro * (+15) /* Pages I find interesting */ 09:58:24 [[User:Orby]] https://esolangs.org/w/index.php?diff=152764&oldid=152763 * 2ro * (+28) /* Pages I find interesting */ 10:00:01 [[User:PrySigneToFry/Sandbox]] https://esolangs.org/w/index.php?diff=152765&oldid=152624 * PrySigneToFry * (+1) 10:19:22 -!- craigo has joined. 10:20:34 -!- craigo has quit (Client Quit). 10:21:20 -!- craigo has joined. 10:50:58 -!- amby has joined. 10:52:26 [[SpeechProg]] N https://esolangs.org/w/index.php?oldid=152766 * MihaiEso * (+1205) Created page with "'''SpeechProg''' is a esolang by Mihai Popa. You use natural language for programming. == Syntax == Comments are done with a hash, but unit tests exercising this code are done with a greater-than sign. == Examples == === [[Hello, world!]] === 
 On "Say Hello,
10:53:58  [[SpeechProg]]  https://esolangs.org/w/index.php?diff=152767&oldid=152766 * MihaiEso * (+201) 
10:54:28  [[User:MihaiEso]]  https://esolangs.org/w/index.php?diff=152768&oldid=152748 * MihaiEso * (+43) 
10:55:00  [[Language list]]  https://esolangs.org/w/index.php?diff=152769&oldid=152753 * MihaiEso * (+17) /* S */
11:03:28 -!- Everything has joined.
11:17:12  Hi
11:31:01 -!- Everything has quit (Ping timeout: 248 seconds).
11:32:40  [[SpeechProg]]  https://esolangs.org/w/index.php?diff=152770&oldid=152767 * MihaiEso * (+1) /* Count from 1 to 10 */
11:45:36  [[Project Euler/2]]  https://esolangs.org/w/index.php?diff=152771&oldid=152675 * Calculus is fun * (+188) MoreMathRPN example
11:50:47  [[MoreMathRPN/ProjectEulerExamples]] N https://esolangs.org/w/index.php?oldid=152772 * Calculus is fun * (+192) Created subpage for Project Euler
11:51:50  [[MoreMathRPN]]  https://esolangs.org/w/index.php?diff=152773&oldid=152626 * Calculus is fun * (+22) /* Examples elsewhere on this site */
11:52:22  [[MoreMathRPN]] M https://esolangs.org/w/index.php?diff=152774&oldid=152773 * Calculus is fun * (-25) /* Examples elsewhere on this site */
11:52:31  [[MoreMathRPN]]  https://esolangs.org/w/index.php?diff=152775&oldid=152774 * Calculus is fun * (-1) /* Examples elsewhere on this site */
12:04:18 -!- mtm has quit (Ping timeout: 252 seconds).
12:05:56 -!- mtm has joined.
12:20:24  [[User:GluonVelvet]] N https://esolangs.org/w/index.php?oldid=152776 * GluonVelvet * (+208) Created page with "Season's greason's! I'm Velvet, a silly jr dev with an interest in esolangs. I have a lot of ideas, most of which won't be made, but feel free to steal them if I say you can.  I'll make an esolang some day..."
12:24:10  [[User talk:MihaiEso]]  https://esolangs.org/w/index.php?diff=152777&oldid=152762 * Hotcrystal0 * (+107) 
12:27:23  [[Project Euler/5]] M https://esolangs.org/w/index.php?diff=152778&oldid=152613 * Calculus is fun * (+167) /* Implementations */
12:39:31  [[MoreMathRPN/ProjectEulerExamples]] M https://esolangs.org/w/index.php?diff=152779&oldid=152772 * Calculus is fun * (+44) 
13:13:36  [[SpeechProg]]  https://esolangs.org/w/index.php?diff=152780&oldid=152770 * MihaiEso * (+692) /* Say if a number is a perfect square */
13:20:45  [[User talk:BrainFuckGirl]]  https://esolangs.org/w/index.php?diff=152781&oldid=152730 * BrainFuckGirl * (+799) /* Question */
14:11:48  [[Pointing]]  https://esolangs.org/w/index.php?diff=152782&oldid=152756 * Calculus is fun * (-13) Remove WIP tag
15:05:39  [[SpeechProg]]  https://esolangs.org/w/index.php?diff=152783&oldid=152780 * MihaiEso * (+1878) /* Square root and cube root of pi and e */
15:32:36  [[Topple]] M https://esolangs.org/w/index.php?diff=152784&oldid=152198 * H33T33 * (-23) 
16:25:05 -!- CanisCorvus has joined.
17:17:49  [[User talk:BrainFuckGirl]]  https://esolangs.org/w/index.php?diff=152785&oldid=152781 * MihaiEso * (+420) 
17:18:52  [[User:BrainFuckGirl]]  https://esolangs.org/w/index.php?diff=152786&oldid=152706 * MihaiEso * (+0) /* Hello, world! */
17:40:43  [[Special:Log/newusers]] create  * PhongEsolang369 *  New user account
17:55:32 -!- CanisCorvus96 has joined.
18:12:22 -!- Everything has joined.
18:35:30 -!- Everything has quit (Quit: leaving).
18:37:28 -!- Everything has joined.
18:38:26 -!- ais523 has joined.
19:16:38  [[Talk:UserEdited]]  https://esolangs.org/w/index.php?diff=152787&oldid=140443 * Hotcrystal0 * (+160) 
19:33:46  [[Deadfih]] M https://esolangs.org/w/index.php?diff=152788&oldid=152081 * Krolkrol * (+1) 
19:47:49  [[User:PrySigneToFry/Sandbox/Users that is also on other place]]  https://esolangs.org/w/index.php?diff=152789&oldid=152079 * I am islptng * (+137) 
19:52:47  I had some ideas about version control system gopher://zzo38computer.org/0textfile/miscellaneous/VersionControl do you have any comments about this?
19:53:15  (in case something is missing or something there is unnecessary or something else is wrong with it)
19:58:10 -!- chiselfuse has quit (Remote host closed the connection).
19:58:42  [[User:I am islptng/My rate to the user I know]]  https://esolangs.org/w/index.php?diff=152790&oldid=149600 * I am islptng * (+66) 
20:01:29 -!- chiselfuse has joined.
20:05:03  [[Mutzerium]]  https://esolangs.org/w/index.php?diff=152791&oldid=152759 * I am islptng * (-14) /* Greatest Common Divisor */
20:16:59  zzo38: Cool. Thanks for sharing.
20:17:35  Having recently worked through git's object model, I find your setup to be much more complex and specialized. There are a couple points where I think that your divergence from git is interesting enough to explore in more detail.
20:17:59  Hmm the Sea Magic endgame has more depth than I thought... I thought my 17255 points were pretty good but people are getting close to 19k. Ooph.
20:18:33  I don't know if you've considered it, but when writing something like this, a companion document titled "Why not Brand X, my obvious competitor?" can be very helpful.
20:18:48  For example, I wrote this document "Why Not Python?" when designing Monte: https://gist.github.com/MostAwesomeDude/eee722a254adc100062c1921cfa4dfc9
20:19:37  It's a particular kind of rationale.
20:19:48  zzo38: Anyway, my specific observations. First, the choice to make sets primitive, instead of dicts, is interesting. I have desired sets, lists/sequences, and tuples in git's object model, and it's frustrating that I have to hack them with dicts that have magic key names.
20:20:26  Second, a version-control system is a name-management system; we have artifacts, *and* we want to name them, tag them, bag them, etc.
20:20:36  I'd love to read more words about how to manage names.
20:32:09  my computer apparently doesn't know how to open Gopher URLs – the OS tries to open them with Firefox and Firefox tries to refer them to the OS
20:34:58  It's odd that Firefox somehow ended up assigned to them
20:35:47  yes – the OS thinks that Firefox should know how to open them, but is apparently mistaken
20:36:09  hege
20:36:46  It may be a manual configuration dating back to times when Firefox supported gopher? Though that was dropped 15 years ago...
20:37:16  I use Lynx for Gopher. There used to be Firefox support, then there was a plugin, then they said that extensions couldn't implement Gopher or FTP or other protocols.
20:37:19  (Was it even Firefox then?)
20:37:38  https://bugzilla.mozilla.org/show_bug.cgi?id=388195 "Target Milestone: mozilla2.0 → mozilla1.9.3a6"
20:39:26  korvo: I'm reading your "why not Python?" document because I like reading that sort of thing (even though I generally dislike Python enough to not want to use something similar)
20:40:21  the [(lambda y: x + y) for x in range(5)] example is interesting in Rust – Rust has two sorts of closures, one which moves x into the closure, one which refers to the x outside the closure – but the latter type of closure (which is the default) doesn't compile because it won't let the for loop change the value of x while something is borrowing it
20:40:24  ais523: I hope it's enlightening! Most of it is well-trodden folklore inside the Python community, but if you're not a regular then you might get a kick (or a tick) out of the lambda quirk.
20:41:49  https://play.rust-lang.org/?version=stable&mode=debug&edition=2024&gist=cd5791d62c6d5891e1fdd254fc2bf93a
20:41:59  Ha, yeah. C++'s approach is interesting too; there's only one sort of lambda, the preferred (default?) annotation is `auto`, and the programmer is forced to accept C++'s fairly loose move semantics.
20:42:31  I think neither Rust nor C++ lets you easily name the type of a closure
20:43:06  (Rust does let you name the type of a function that doesn't close over anything, and lambdas can generate those if they don't capture, but normally you want to capture things in your lambda)
20:43:46  Sure. Monte doesn't really make closures or lambdas or other code objects easy to guard; we kind of assume that a callable behavior is always tamed into something more specific to the code that uses it.
20:43:55  korvo: I will respond to you. You are right about naming them, but they can be referred to either by hash or by tags (like Fossil and I think git does something similar, too).
20:44:35  shadowing builtins is interesting – I think some languages explicitly permit that so that new builtins can be added without breaking backwards compatibility
20:44:49  [[User:PrySigneToFry/Sandbox/Users that is also on other place]]  https://esolangs.org/w/index.php?diff=152792&oldid=152789 * Hotcrystal0 * (-57) Removed email (please dont share that)
20:44:58  If the closure doesn't actually close over anything, you can coerce it to an fn(Foo) -> Bar
20:45:20  FreeFull: I'm not even sure that that acutally is a coercion (as opposed to the lambda naturally having that type)
20:45:22  Otherwise, the best you can do is the Fn* traits
20:45:23  About using sets insteadof dicts, the kind of data to me seems to mean that sets are helpful, since it is a set of attributes, and most kind of attributes can occur more than once (although attributes 4 and 5 should not occur more than once.
20:45:50  FreeFull: well you can name it using type alias impl Trait, except that I think that might still be unstable
20:45:51  ais523: Well, for regular named functions, it actually is coercion
20:46:04  zzo38: Of course. What I've found to be a hassle is the *act of naming*. Do you know the parable of the cat from the Python community?
20:46:19  So `fn foo(x: Foo) -> Bar {...}` has a unique type, which can coerce to fn(Foo) -> Bar
20:46:30  ( This is for Rust, I have no idea about how C++ handles things )
20:46:44  FreeFull: ah right, so that the compiler knows what specific function is being called in the case where you aren't using a function pointer, and can optimise on that assumption
20:46:55  it probably does that for lambdas too, then
20:46:57  Yeah, something like that
20:47:07  I can't find a direct link, but in short, a cat doesn't have a name. A cat might have nametags attached to it, and multiple people around the neighborhood might call it by various names, but the cat doesn't actually *have* a name. So it goes with Python objects, and in this case, with content-addressed data.
20:47:16  korvo: I do not use Python programming much (I think I only ever used it for two things; one is to add new card games into PySol, and one is to improve a hard drive wiping program to also test them)
20:47:22  It does rarely cause confusing error messages, when the coercion doesn't happen automatically
20:47:43  korvo: Oh so it's like Tolkien characters :P
20:47:50  int-e: Another solid example!
20:49:00  Part of why I wanted to put Cammy into git was to erase the problem of names. I don't want to choose names for expressions. I do want to know when I have multiple names for an expression, but I don't want to manually de-duplicate all of the intermediate code.
20:49:02  Perl's approach to builtins is weird – variables have a sigil so that they can be distinguished from builtins, and thus it's fine to have a variable and builtin with the same name
20:49:27  (In this case, an object does actually have a "canonical" name, which is its hash.)
20:49:43  but, function names aren't namespaced (and IIRC can shadow builtins), and an identifier that would otherwise have no other interpretation is treated as a string literal (with a warning that it might be used as a builtin name in future)
20:50:19  I vaguely remember that the identifiers-as-string-literals thing was intended to make writing poetry in Perl possible, rather than having some intended use in regular programming
20:50:46  ais523: I'd guess you might know PHP as well? Its only corner of elegance is that `$` is effectively a Tcl-style quoting operator which lifts name literals to variable references. So `$$name` performs two lookups in the scope, dereferencing twice. Hints of Three Star Programmer.
20:51:53  korvo: IIRC that's usually considered a misfeature, despite having a sort of twisted elegance to it
20:52:08  I don't know very much PHP – enough to sometimes be able to read PHP code if I need to do that for some reason
20:52:33  I think I have a PHP interpreter installed for testing something or other, but it was probably a polyglot
20:52:49  ais523: Oh, of course, like all of PHP, it's quite bad design for readability or maintainability, and most linters forbid even $$ lookups, let alone $$$. But I wonder if Three Star Programmer could be embedded as an esoteric subset.
20:53:17  you'd have to be able to generate arbitrarily many variable names at runtime but PHP probably allows that
20:53:45  does it allow numbers as variable names if you name them indirectly (or even directly)?
20:54:23  Perl does, although they're reserved variables that might have side effects on being assigned to
20:54:36  Yeah, I don't recall the syntax offhand but there's a way to parse names as strings into ints, and so we could have a scope whose keys are stringified nats and values are plain PHP integers.
20:55:08  It's some utterly bonkers C-style syntax like `$i := (int) $s` but that's not a casting operator and `int` isn't a token.
20:55:22  bleh, apparently it just errors on attempts to assign to $1 and friends even when there's an obvious meaning
20:55:43  I was hoping «my $x = "abc"; $x =~ /(b)/; $1 = "d"; say $x» would output "adc" but it doesn't
20:56:08  (this probably wouldn't be expected behaviour in any other language but I think it's expected behaviour in Perl)
20:56:52  Does it output "ac" or error? I can't actually read Perl.
20:57:04  errors, "Modification of a read-only value attempted"
20:57:15 -!- Everything has quit (Quit: leaving).
20:57:44  =~ is a regex match with no immediate side effects, it just checks whether $x contains the character 'b' and (due to the parentheses) sets $1 to the substring of $x that is the 'b'
20:58:32  I also think that identifiers-as-string-literals is not a very good feature (although it might make sense if it is a separate "name" type instead, maybe; PostScript does have a separate "name" type although its value can only be a short character sequence without undescribable names)
20:59:51  some languages have a "symbol" or "atom" type for which the possible values are the possible identifiers – but generally they need some sort of sigil to specify that you want the symbol/atom rather than for the identifier to be interpreted
21:01:18  Prolog doesn't need atoms to be quoted or sigilled at all – meanwhile, Lisp primarily lets you get at them via using macros to steal them from an AST (but there's a "quote" macro which is good for naming atoms, and most Lisp interpreters let you abbreviate the macro to ' so it acts a lot like a sigil)
21:01:19  In PostScript you use a slash in front for that purpose
21:02:32  I wish (gensym) were available for that in Prolog or miniKanren. I understand the soundness issues, but I also don't like that they're pushed wholly onto the user.
21:03:04  I tend to write the sort of Prolog programs where a gensym wouldn't be useful, but can see how it could be for some types of programming
21:03:08  There is a variant of miniKanren with nominal logic (search "aKanren"?) that has a gensym form. It's a pain to implement and work with.
21:03:41  I guess it wouldn't be so bad if the gensym just leaked symbols if you backtracked past it, rather than trying to clean them up
21:04:04  it probably wouldn't be so hard to build one of those out of a pile of asserts and retracts
21:04:18  ais523: Type-checkers are the typical example for me. Gotta somehow turn non-ground logic variables into symbolic names when the type is extracted. Pointed program synthesis is another example, and part of why I prefer pointfree programming.
21:04:21  [[User:I am islptng/My rate to the user I know]]  https://esolangs.org/w/index.php?diff=152793&oldid=152790 * I am islptng * (+10) 
21:05:26  Right. I don't care if the variable is called "v12" or "v143" or whatever. It'd be nice if the gensym took an optional parameter so that I could preserve original names, but that's easy enough to build on top.
21:05:35  korvo: Prolog's actually very good at meeting the first of those requirements, output functions generally have a way to consistently replace unbound variables with variable names in the output (without changing the internal state of the code) and will use different names for different outptus
21:06:11  the hard part is maintaining "these are actually different" constraints to prevent your various unbound variables unifying with each other in cases where they aren't supposed to
21:06:44  Oh, sure. But Veblen's syntax theorem applies; for example, somewhere in my Cammy type-checker, there's a string that looks like "XYZWSTUV"... naming type variables, and it is a finite string.
21:06:45  Prolog meta-interpreters almost always absorb variable unification, but I imagine you would have these sorts of trouble if you tried to reify it…
21:07:13  I know it's a little big of me, but I want to be grumpy about the concept of nomenclature.
21:07:41  About the "why-not-python.rst", I think what is mentioned there is good ideas, although I also think that Unicode string types as the main string types is a bad idea. Capability safety is a good idea, although I think that capability-based security is a good thing to have in the operating system, but it could also be used in a programming language.
21:07:56  (I also dislike the indentation-based syntax; Haskell allows but does not require it)
21:08:27  I do like the "basically just a list of integers" string type, I think that's the main alternative to Unicode strings nowadays
21:08:36  zzo38: Yeah. From a chat with one of the CHERI designers, there's this idea that cap-safety is a property of the whole machine; so the hardware, OS, and userland need to work together to preserve it.
21:09:55  having hardware enforcement helps, although I think capability-safety is possible using just the OS and software, without hardware help (but then you need a static analyser to be able to run untrusted binaries capability-safely)
21:11:39  or, I guess my viewpoint is "it is a property that programs may or may not have that they don't attempt to break capability-safety – for a useful subset of programs it is possible to prove it, and (assuming capabilities can be safely discarded without violating their type system) for all programs it is possible to add runtime checks to abort them before they try to violate it)"
21:11:57  [[UserEdited]]  https://esolangs.org/w/index.php?diff=152794&oldid=152690 * I am islptng * (+310) 
21:12:22  and that means that capability-safety can be enforced either in software or hardware, and either at runtime or compile/verify-time, you just have performance tradeoffs to make
21:12:58  Sure. We can unwrap that directly in terms of isolation, FWIW; we don't have to have the high-minded abstract idea of a capability, not when we're using bit-oriented machines. Given two object graphs in the machine, if they ought to be isolated, then cap-safety requires that they actually be isolated. That's it.
21:14:00  This is usually where the dialog with descendants of ALGOL breaks down; folks raised in C or Python will, once they grok object graphs, note that of course isolation is never achieved and -- worse -- that it is an undesirable property.
21:14:09  one thing I have been considering is a type-safe assembly language (perhaps with explicit type annotations rather than type inference), partly to make verifying safety properties possible without spending a large amount of time compiling, partly because I think existing compilers often do steps of the compile in the wrong order and it leads to inefficiencis
21:15:11  But e.g. paravirt exists; it's possible for the hardware, OS, and userspace to coordinate so that two userspace object graphs are genuinely isolated! The C folks have long since descended into reactionism over this; Python folks are more open to e.g. adding subinterpreters to CPython.
21:15:50  oh, I definitely think that programming languages are working from the wrong direction in terms of isolation – most languages start with allowing free sharing by default and then try to add restrictions to make programs easier to reason about – I think it's better to start fully isolated and then add just the minimum amount of sharing needed to get a usable language
21:16:26  Yes please. This is what I mean when I spout memes like "SLTC is cap-safe by default"; SLTC can genuinely isolate two sub-computations so that they can be executed in parallel.
21:17:21  And everybody loves to worship lambdas and first-order types, right? So the problem is that the typical programming language is full of "ambient authority" which breaks isolation in too many ways.
21:18:00  recently I have been lamenting just how bad compilers are at vectorising things to SIMD – I've been envisioning a world in which functions are compiled as SIMD by default and will run SIMD on vector arguments
21:18:26  Elm and its descendants are one of my favorite punching bags on this. Elm's nearly cap-safe, except that they didn't actually design their stdlib around this. So they have a fake notion of purity and a bunch of untamed functionality that they lock themselves away from exposing.
21:18:30  and I think the reason we don't have that is that, e.g., our existing control flow operations aren't isolating enough
21:19:02  in most languages, a for loop doesn't attempt to isolate the iterations from each other, so it is hard for compilers to execute them in parallel
21:19:10  Yep. E has internal iteration for this reason; they didn't just copy it from Smalltalk, but thought through the consequences of running loop iterations in parallel.
21:20:10  hmm, I wonder whether Rust's «Fn + Sync» is strong enough for that, or whether there's some way to bypass isolation using that for internal iteration
21:20:35  I guess you could communicate between parallel executions of the function using atomics or mutexes, which is probably intended behaviour
21:20:35  E was such a hard read. So many slightly-wrong guesses. `x ** y % z` does modular exponentiation, for example. They couldn't have guessed the timeline where Intel developed AES-NI.
21:21:36  doesn't x ** y % z mean modular exponentiation in any language where integers are unbounded by default? so it could be implemented as an optimisation
21:21:49  ah no, y could be negative
21:22:22  (admittedly the function isn't fully defined in that case, but that wouldn't prevent a language evaluating it in cases where it is defined)
21:24:50  It's a mixfix three-parameter op. It expands like e`x.modExp(y, z)` IIRC. In most languages, it would be grouped as `(x ** y) % z` which overflows.
21:25:25  right – I was thinking of it as (x ** y) % z evaluated on bignums and then optimised to reduce memory usage
21:25:29  They were anticipating something like ED25519, which IIUC was extremely hot research tech at the time.
21:25:58  but having a genuine three-arguement operator does help in cases where y is negative
21:26:30  E didn't have bignums! It follows the idea that the machine has only like two underlying numeric types, which it calls `int` and `double`. I wish I knew the root of this philosophy, as it's the same as C's default rules and Python 3's rules.
21:26:46  meanwhile, I've read a bit further in your document and think that the "Plan Coordination" section is actually a criticism of how the "for" loop works – it isn't iterating over the entire list on exception and it's allowing the list that's being iterated over to be changed
21:27:22  But you had to ask for like a java.system.Integer or whatever if you wanted a bignum. They eventually wrote a wrapper for this. Monte does do bignums by default, but that's because I think working over *the* ring of integers is nicer than *some* machine-dependent ring.
21:27:58  [[UserEdited]]  https://esolangs.org/w/index.php?diff=152795&oldid=152794 * I am islptng * (+123) /* Commands */
21:28:05  or, I guess my opinion on that is "changing a list that you're iterating over is not typically defined behaviour – languages should either prevent it or define the behaviour, but whatever their choice it might not be what you meant by doing that"
21:28:18  [[UserEdited]]  https://esolangs.org/w/index.php?diff=152796&oldid=152795 * I am islptng * (+4) /* 99 bottles of beer */
21:28:31  ais523: If you can read Java, I *highly* recommend the original linked paper. Plan interference is one of those kind of higher-level language-independent things that matters whenever machines are chimeric.
21:28:50  there was a big discussion recently about what it means to call exit() from an atexit() handler – this is UB according to the C specification but some OS vendors have decided to allow it, and have been trying to give semantics
21:29:05  I honestly think that my Python transcription here is quite bad. It was meant to communicate a point to CPython's devs, not to y'all.
21:29:28  fair enough – it can take some time to read papers but I probably should read that one
21:29:57  And yeah, exceptions thrown during exception-handling are another good example. In that case, the relevant capability is control over the return stack. We can imagine a call/cc analogue too.
21:30:20  also my previous job was a) in Java and b) writing a program that took Java programs as input, so I can read it pretty well and know probably a lot more corner cases than the typical Java programmer would
21:31:00  I have increasingly come round to an "if an exception is thrown while running a method that could mutate object X, object X no longer exists" point of view
21:31:17  ais523: Just chew on the first five pages or so, that's all. E's solution is merely to deliever the .statusChanged() message on an async basis, with isolation between each delivery. Exceptions in one delivery don't affect the others.
21:31:25  which is somewhat extreme, but seems to be one of the few ways to guarantee correctness in that case
21:31:43  Messages are delivered in partial order, more or less, and again that's to ensure that one status can't stomp another unfairly.
21:31:53  query hackeso
21:31:58  [[UserEdited]]  https://esolangs.org/w/index.php?diff=152797&oldid=152796 * Hotcrystal0 * (+448) 
21:33:00  I think it's possible to make the thing mentioned in my last two messages work with only minor modifications to Rust's type system (especially because catching exceptions is rare in Rust and Rust already tracks mutable references)
21:33:48  ais523: Honestly I love that heuristic and I might keep it, because that's also how RPython's stack works when X's class has a finalizer; X may be ready to reap but not yet finalized, and accessing it again would be improper.
21:34:25  ...Maybe it's a general thing when we have weakrefs or ephemerons. I haven't been bitten by this in Scheme, but mostly because I refuse to build anything of that complexity there.
21:35:08  ais523: re x ** y % z , not quite, but python has a pow builtin function for exponentiation where pow(a,e) is the same as a**e, but pow(a,e,m) is modular exponentiation a**e%m, and the latter works even if e is negative to compute a modular inverse
21:35:21  for what it's worth, the "Using threads to deliver updates asynchronously." attempted fix is I think actually close to a solution whilst missing the point – what's required is not the actual thread, but the thread-safety
21:35:38  the negative case is allowed only from python 3.8; HackEso has python 3.7 so I can't demonstrate here
21:35:41  b_jonas: that seems like a useful builtin
21:36:06  [[UserEdited]]  https://esolangs.org/w/index.php?diff=152798&oldid=152797 * Hotcrystal0 * (+1) 
21:36:19  `python3 -cm = 3583; a = 1433; b = pow(a, -1, m); print(m, a, b, (a*b)%m) # try in python 3.8 or later
21:36:20  Traceback (most recent call last): \   File "", line 1, in  \ ValueError: pow() 2nd argument cannot be negative when 3rd argument specified
21:36:34  the main project I've been working on recently is a golfing language that's going to be full of builtins like that, although unfortunately that one naturally takes three arguments which is syntactically awkward for what i'm doing
21:36:36  ais523: Right. And in fact threads aren't a great primitive for this because they have zero isolation by default.
21:37:03  indeed, threads are so messy that you need thread-safe code to even have a chance of using them safely
21:37:05  also J has a way to get modular exponentiation for integers, but I don't recall if it can do negative exponents
21:37:15  so that means that thread-safety gives you fairly strong guarantees that can be useful in other situations too
21:37:47  that said, this might need a slightly stronger safety notion – some common thread-safety mechanisms rely on the fact that threads can run concurrently to avoid deadlocking
21:37:50  E is usually implemented as a set of isolated object graphs ("vats"). Communicating between them is done by delivering one message to one node in one vat ("taking a turn"); any outgoing messages are enqueued in partial order.
21:38:59  so either the loop that dispatches to listeners needs to be able to run them concurrently (allowing locking to work) or the listeners need a slightly higher level of safety (usually called async-signal-safety) in which any of them can run successfully if any of them are blocked at an arbitrary point in their execution
21:39:03  And then, if one had the need, one could implement a runtime that schedules vats in threads. However, in multiple projects, I've found that it works better to schedule vats to processes.
21:39:40  korvo: this is a familiar problem, I think basically the same problem has come up in lots of other languages too
21:40:17  it's a bit of an annoying problem because there are a lot of different approaches that work, making it hard to figure out which is the most promising
21:41:29  I should get back to writing that async-signal-safe malloc some time – it seems a) useful and b) fairly easy as async-signal-safe code goes
21:42:06  Sure, it's an ancient argument and one that shifts with each new OS or userspace threading library.
21:43:01  ideally code would be generic enough that you could just swap the async runtime out
21:43:07  that usually doesn't seem to happen in practice, though
21:43:11  The nice thing about scheduling vats to processes, once it can be done over a network, is that scheduling becomes *agoric*. I use this in the communist sense: it becomes open to expansion, to using resources as they are available.
21:43:39  ...Most of the other cap-safety folks will be using it in the libertarian sense: it is open to purchase on a market.
21:45:13  This might sound a lot like being embarrasingly parallel. Indeed, vats can take turns with perfect parallelism; the actual throughput is mostly determined by queueing theory and how messages pile up in mailboxes, rather than the gristle from Amdahl's Law.
22:01:42 -!- craigo has quit (Quit: Leaving).
22:03:49  hmm, going back to the closure capturing thing, I suddenly remembered how Java does it – it doesn't let you capture mutable variables at all, you need to copy the value to an immutable variable first in order to capture it (which then makes it irrelevant whether you're capturing the variable's value or the variable itself)
22:04:15  in a way, I like that from the "the code's behaviour is clear from reading the program" point of view
22:37:36  ais523: yes but on the other hand, I think in R5RS Scheme, capturing a mutable local variable as an upvalue in a function is the canonical way to create an object on the heap that has a mutable slot that can point to other objects. R5RS doesn't have a way to add user-defined structure types (later versions of Scheme do). It has set-car! and set-cdr! but I think the language is designed such that most 
22:37:42  programs don't want to allow these and an interpreter would want to optimize the case where all conses are immutable and would have to use a less efficient implementation if the program can mutate them. And it has vectors with mutable elements, but then you have to use numeric indexes, and the vectors might not be optimized for the case when they're short. And you could even have a very small (thus not 
22:37:48  compliant with R5RS) version of Scheme that's kind of like untyped lambda calculus but with the set! primitive added to mutate local variables. Also arguably Lua is similar to Scheme in this respect.
22:40:04  I think in Lua 5.3, both pure Lua and the C interface are designed this way, though I'm not entire sure because it's been a while since I looked at it
22:42:20  b_jonas: huh, somehow it makes sense to me to have a Lisp creating a mutable variable by stealing it from a stack frame, just like the way it creates atom and list literals by stealing them from an AST
22:43:01  Compare this to Standard ML where everything is immutable by default, both local variables and the slots in user-defined algebraic structures, and if you want a mutable slot there's an explicit library type for it, with three functions, one to create a new one, one to read, and one to write. 
22:43:17  s/Compare/Contrast/
22:44:05  ais523: I don't think that's the default way to create list literals. That's the library function called list.
22:44:15  I've used OCaml fairly heavily, which does have actual language support for mutable struct fields but it's most commonly used in a Standard-ML-like style where you have functions/operators for creating/reading/writing a mutable slot
22:44:38  b_jonas: do people not normally just write '(a b c) rather than (list 'a 'b 'c)?
22:45:06  or am I forgetting how Lisp works? (I'm not very good at Lisp)
22:45:51  ais523: I'm not sure, I think the sort of people who use lisp mostly to write lisp interpreters write it as '(a b c); whereas the type of users who write practical programs will rarely want to use lists of symbols
22:46:14  ah, I see
22:46:50  now I'm wondering whether '(1 2 3) is capturing the numbers 1, 2 and 3 themselves, or whether it's capturing some sort of syntactic element that evaluates to those numbers – I think it's the former but I'm not completely sure
22:46:57  you could use a few symbols as extra sentinel values, though #f (which is what Scheme calls the boolean value false) is usually easier
22:47:11  ais523: numbers.
22:47:24  they evaluate to themselves
22:47:32  oh, huh, it's weird for me to see booleans in a Lisp-alike, I'm used to the really old-fashioned nil and t
22:47:58  which admittedly isn't very type-safe (as nil is also an empty list)
22:48:31  yes, Scheme added booleans, and uses it for the if builtin and for various library functions that return a boolean such as type checking functions and comparisons
22:48:56  thinking about it, Prolog calling its empty list atom [] makes so much more sense
22:49:28  (I kind-of think of Prolog as being vaguely in the Lisp family, or at least a descendant)
22:50:01  I do like user-definable structures which can have mutable slots, later versions of Scheme add them, and that's also how Python3 works
22:50:28  that's one of the big differences between Standard ML and OCaml, although I basically never use them
22:51:06  although, I mostly gave up on OCaml in favour of Rust – most of the features I most like in OCaml got stolen by Rust, and it's easier to build
22:51:08  you could even have a language where those are the only way to get something mutable, though for efficiency reasons languages usually have arrays and dictionaries with mutable slots
22:51:55  I guess you could have an array *of* mutable slots (as opposed to an array that had them naturally) and then optimize
22:52:52  that's basically what Rust does if you want an interior-mutable array, you could use something like Vec> (although that couldn't be resized while it's shared, so maybe a custom type would work better)
22:55:58  also some languages allow special garbage collector magic that only makes sense with mutability, as in either to have a weak key field in a user-defined structure where if the thing that the weak key points to is garbage-collected then the structure is no longer alive and can also be garbage-collected, or the structure can have a destructor slot that's called when the garbage collector collects the 
22:56:04  structure. you can't easily do these shenanigans if your only mutable thing is local variables captured by lambda 
22:56:34  heck, or just weak references in first place
22:56:43  you can't make weak references out of lambda closures
23:13:34  [[Bitchanger Busy beaver]]  https://esolangs.org/w/index.php?diff=152799&oldid=152563 * Int-e * (+867) Extend results
23:13:58  [[Bitchanger Busy beaver/Proof]] N https://esolangs.org/w/index.php?oldid=152800 * Int-e * (+1776) Replicate and extend results.
23:15:32  Uhm. That wasn't right.
23:16:13  [[Bitchanger Busy beaver/Proof]]  https://esolangs.org/w/index.php?diff=152801&oldid=152800 * Int-e * (+6346) Whoops, that was the wrong contents.
23:17:34  <3 writing inefficient code that's good enough.
23:17:53 -!- CanisCorvus has quit (Quit: Client closed).
23:20:23  [[Bitchanger Busy beaver/Proof]] M https://esolangs.org/w/index.php?diff=152802&oldid=152801 * Int-e * (+1) /* Size 14 holdouts */ Counting is hard ;-)
23:27:40  [[Bitchanger Busy beaver]]  https://esolangs.org/w/index.php?diff=152803&oldid=152799 * Int-e * (+41) Cosmetics, link to language.
23:28:05 -!- Sgeo has joined.
23:29:58  [[Talk:Bitchanger Busy beaver]]  https://esolangs.org/w/index.php?diff=152804&oldid=152551 * Int-e * (+180) Mention updates here too.
23:41:40  [[User:Buckets]] M https://esolangs.org/w/index.php?diff=152805&oldid=152643 * Buckets * (+8) 
23:41:52  [[Language list]] M https://esolangs.org/w/index.php?diff=152806&oldid=152769 * Buckets * (+9) 
23:42:06  [[((]] N https://esolangs.org/w/index.php?oldid=152807 * Buckets * (+1254) Created page with "(( is an Esoteric programming language created by [[User:Buckets]] in 2024. (-, /, ^ and v are the only usable operations( v is a operation that is the nth Placement number of the other number).) {| class="wikitable" |- ! Commands !! Instructions |- | t || This is
23:50:24  [[((]] M https://esolangs.org/w/index.php?diff=152808&oldid=152807 * Buckets * (+103) 
23:53:44  [[Weeeeeeeeeeeeeeeeeeeeeeeeeeeeee]]  https://esolangs.org/w/index.php?diff=152809&oldid=128071 * Hotcrystal0 * (+29) Adding a missing category
23:53:59  [[Weeeeeeeeeeeeeeeeeeeeeeeeeeeeee]]  https://esolangs.org/w/index.php?diff=152810&oldid=152809 * Hotcrystal0 * (+2)