00:00:33 -!- X-Scale has quit (Ping timeout: 256 seconds).
00:03:02 -!- 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:19:54 <esolangs> [[BF Joust strategies]] https://esolangs.org/w/index.php?diff=143161&oldid=143160 * Ais523 * (+14) /* 2024 */ fix a mistake in the description
00:28:05 -!- impomatic has quit (Quit: Client closed).
00:34:18 <esolangs> [[BF Joust strategies]] https://esolangs.org/w/index.php?diff=143162&oldid=143161 * Ais523 * (+1964) /* Reconnaissance */ mention tape length estimation
00:34:55 <esolangs> [[BF Joust strategies]] M https://esolangs.org/w/index.php?diff=143163&oldid=143162 * Ais523 * (+1) /* Tape length estimation */ grammar
00:35:48 <esolangs> [[BF Joust strategies]] https://esolangs.org/w/index.php?diff=143164&oldid=143163 * Ais523 * (+66) /* Tape length estimation */ fix broken parenthetical
00:39:07 <esolangs> [[BF Joust strategies]] https://esolangs.org/w/index.php?diff=143165&oldid=143164 * Ais523 * (+37) /* Anti-shudder clear */ clarify
00:41:13 <esolangs> [[1 byte :5]] https://esolangs.org/w/index.php?diff=143166&oldid=127866 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+25) /* Interpeter */
00:42:09 -!- X-Scale has joined.
00:50:34 <esolangs> [[BF Joust strategies]] https://esolangs.org/w/index.php?diff=143167&oldid=143165 * Ais523 * (+1202) /* Defense */ discuss flag repair
00:53:48 <esolangs> [[BF Joust strategies]] https://esolangs.org/w/index.php?diff=143168&oldid=143167 * Ais523 * (+220) /* Flag repair */ mention interaction with careless clears
01:00:46 <esolangs> [[1 byte :5]] https://esolangs.org/w/index.php?diff=143169&oldid=143166 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+23) /* Interpeter */
01:14:52 <esolangs> [[Cut]] https://esolangs.org/w/index.php?diff=143170&oldid=79586 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+65) /* Example programs */
01:15:22 <esolangs> [[Cut]] https://esolangs.org/w/index.php?diff=143171&oldid=143170 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (-4) /* Example programs */
01:22:38 <zzo38> Why does ASN.1 BER need the specification of which of the three kind of ISO 6093 formats is used?
01:31:22 <esolangs> [[Snakel (Ractangle)]] M https://esolangs.org/w/index.php?diff=143172&oldid=143154 * PythonshellDebugwindow * (+42) Categories
02:04:38 -!- X-Scale has quit (Quit: Client closed).
02:47:33 -!- X-Scale has joined.
03:47:58 -!- Lord_of_Life has quit (Ping timeout: 252 seconds).
03:49:34 -!- Lord_of_Life has joined.
03:54:41 -!- nitrix has quit (Quit: ZNC 1.8.2 - https://znc.in).
03:56:31 -!- nitrix has joined.
04:13:54 <esolangs> [[Special:Log/newusers]] create * Sei2423 * New user account
04:19:20 <esolangs> [[Langton's ant]] https://esolangs.org/w/index.php?diff=143173&oldid=143133 * Iddi01 * (+235) Fix details
04:31:17 <zzo38> In order to be closer to ASN.1 so that a similar program can be used, I had made up ASN.1X (instead of ASN.2). https://raw.githubusercontent.com/zzo38/scorpion/refs/heads/trunk/asn1/asn1.doc Please tell me if you think something should be changed, or is wrong, or is no good, etc.
04:33:54 <zzo38> (ASN.1X adds some things and removes some things compared with ASN.1, and also adds a few additional restrictions compared with ASN.1)
04:41:02 -!- craigo has quit (Remote host closed the connection).
05:31:14 -!- X-Scale has quit (Quit: Client closed).
07:06:35 <esolangs> [['Python' is not recognized as an internal or external command, operable program or batch file.]] https://esolangs.org/w/index.php?diff=143174&oldid=143149 * Ractangle * (+97)
07:17:28 -!- iddi01 has joined.
07:18:41 <iddi01> !zjoust polexchange (>)*9([-[([(+[{(-)*4(-[{(-)*123[+.]}])%6}])%5][-.]>[(-[{(+)*4(+[{(+)*123[-.]}])%6}])%5][+.]>)*-1]]>)*22
07:18:41 <zemhill> iddi01.polexchange: points -3.74, score 16.68, rank 29/47
07:19:35 <iddi01> In case you haven't figured it out, the previous web.polexchange were also by me
07:42:55 <iddi01> The name refers to it exchanging polarity of clears while doing the rush.
08:28:31 -!- SGautam has joined.
09:10:35 -!- iddi01 has quit (Quit: Client closed).
10:02:52 -!- Lord_of_Life has quit (Remote host closed the connection).
10:03:26 -!- Lord_of_Life has joined.
10:04:28 -!- Lord_of_Life has quit (Excess Flood).
10:05:02 -!- Everything has joined.
10:09:55 -!- Lord_of_Life has joined.
10:24:31 <esolangs> [[User talk:MihaiEso]] https://esolangs.org/w/index.php?diff=143175&oldid=142734 * None1 * (+491) /* Would you like to join Funcode? */ help contributing/translating?
10:24:50 -!- Sgeo_ has quit (Read error: Connection reset by peer).
10:32:57 -!- Everything has quit (Quit: leaving).
10:34:54 <esolangs> [[Cut]] https://esolangs.org/w/index.php?diff=143176&oldid=143171 * PkmnQ * (+92) /* Python implementation */
10:41:38 -!- __monty__ has joined.
10:43:01 -!- X-Scale has joined.
10:45:54 -!- X-Scale56 has joined.
10:48:15 -!- X-Scale has quit (Ping timeout: 256 seconds).
10:51:05 -!- X-Scale56 has quit (Ping timeout: 256 seconds).
11:11:19 <esolangs> [[BF Joust strategies]] M https://esolangs.org/w/index.php?diff=143177&oldid=143168 * Iddi01 * (+638) /* Major Programs */ If you know the exact year, feel free to move them to the correct place
11:28:13 <esolangs> [[Translated ORK/PSTF Again12]] N https://esolangs.org/w/index.php?oldid=143178 * PrySigneToFry * (+2391) Created page with "Translated ORK/Mihai Again8|<span style='font-family:Unifont;'>It is recommended not to rewrite the memory of the com@@? ? uAM@?MA? ?? EE,? ?e M?EMEE?EEM$ #E?AmM?E?? 9uMuu7}? ?e M?EEM?..."
11:28:42 <esolangs> [[Translated ORK/Mihai Again8]] https://esolangs.org/w/index.php?diff=143179&oldid=143123 * PrySigneToFry * (+30)
11:29:13 <esolangs> [[Joke language list]] https://esolangs.org/w/index.php?diff=143180&oldid=143122 * PrySigneToFry * (+63)
11:33:00 <esolangs> [[User talk:MihaiEso]] https://esolangs.org/w/index.php?diff=143181&oldid=143175 * PrySigneToFry * (+774) /* My all Esolangs are designed by ONLY myself until now. */ new section
11:42:01 <esolangs> [[Esolang:Featured languages/Candidates]] M https://esolangs.org/w/index.php?diff=143182&oldid=128341 * Iddi01 * (+984) 1. Proposed [[Langton's ant]] 2. There is *no* obvious rule that says people cannot change their proposal, b_jonas did it and wasn't stopped 3. The syntax guide is outdated, updated it
11:43:28 -!- amby has joined.
12:15:09 -!- tromp has joined.
12:18:39 -!- ais523 has joined.
12:19:41 <ais523> it strikes me that maybe a way to make BF Joust easier to get into is to have a number of "fixed" hills (i.e. new programs never join them, just get scored against them) of varying difficulty
12:19:50 <ais523> so you could try to top the beginner hill first, then the intermediate hill, etc.
12:21:03 <ais523> this also might give practice in tuning to hills with different makeups
12:21:39 <ais523> impatience does as well as it does because it is hard to tune against turtles in modern BF Joust, there are so many other demands on a program's time
12:24:04 <esolangs> [[Translated ORK/PSTF Again12]] https://esolangs.org/w/index.php?diff=143183&oldid=143178 * MihaiEso * (+30)
12:32:45 <esolangs> [[User:Tommyaweosme]] https://esolangs.org/w/index.php?diff=143184&oldid=142476 * Tommyaweosme * (+59)
12:32:59 <esolangs> [[User:Tommyaweosme]] https://esolangs.org/w/index.php?diff=143185&oldid=143184 * Tommyaweosme * (+0)
12:34:21 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
12:35:55 <esolangs> [[User:Tommyaweosme]] https://esolangs.org/w/index.php?diff=143186&oldid=143185 * Tommyaweosme * (+157)
12:36:12 <esolangs> [[User:Tommyaweosme]] M https://esolangs.org/w/index.php?diff=143187&oldid=143186 * Tommyaweosme * (+11)
12:36:29 <esolangs> [[User:Tommyaweosme]] M https://esolangs.org/w/index.php?diff=143188&oldid=143187 * Tommyaweosme * (+0)
12:37:44 <esolangs> [[User:Tommyaweosme]] https://esolangs.org/w/index.php?diff=143189&oldid=143188 * Tommyaweosme * (+12)
12:38:17 -!- tromp has joined.
12:44:15 -!- X-Scale has joined.
12:47:59 -!- SGautam has quit (Quit: Connection closed for inactivity).
12:50:20 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
12:58:15 <esolangs> [[Translated ORK/Mihai Again9]] N https://esolangs.org/w/index.php?oldid=143190 * MihaiEso * (+2109) Created page with "[[Translated ORK/PSTF Again12|<span style='font-family:Unifont;'>It is recommended not to rewrite the memory of the I2712FiZP2;l.6TH=nbReogN?</span>]] 1. Take this T=hTN}<poD1 program: <pre> At this moment// Make a medium cake. Make a medium cake.
12:58:28 -!- Guest5155 has quit (Quit: leaving).
12:59:02 <esolangs> [[Joke language list]] https://esolangs.org/w/index.php?diff=143191&oldid=143180 * MihaiEso * (+64) /* Horribly translated variants */
12:59:09 -!- X-Scale has quit (Ping timeout: 256 seconds).
13:06:55 <b_jonas> ais523: could there instead be a number of fixed programs on the one hill?
13:07:20 <b_jonas> that is, when a new program joins, the lowest scoring non-fixed program gets dropped from the hill
13:13:50 -!- Lord_of_Life has quit (Quit: Laa shay'a waqi'un moutlaq bale kouloun moumkine).
13:17:22 -!- Lord_of_Life has joined.
13:20:21 <esolangs> [[UserEdited]] https://esolangs.org/w/index.php?diff=143192&oldid=142581 * PrySigneToFry * (+2)
13:31:59 <esolangs> [[BF Joust strategies]] https://esolangs.org/w/index.php?diff=143193&oldid=143177 * Ais523 * (+4253) confirmed Sookie's date of topping the hill as May 19 2019, and documenting a reverse-engineering of how it works (because Westonian didn't describe it at the time)
13:33:29 <esolangs> [[User talk:PrySigneToFry]] https://esolangs.org/w/index.php?diff=143194&oldid=143047 * PrySigneToFry * (+721)
13:41:26 <esolangs> [[BF Joust strategies]] https://esolangs.org/w/index.php?diff=143195&oldid=143193 * Ais523 * (+363) /* Major Programs */ mist became #1 on March 11 2019 (before Sookie) move into correct date section and add a reverse-engineered description. (At the time, david_werecat said "<david_werecat> I won't call it generally good, but it works for the current hill.")
13:42:33 <esolangs> [[Olus2000]] N https://esolangs.org/w/index.php?oldid=143196 * Dolphy * (+10463) Created page with "{{infobox proglang |name=Olus2000 |paradigms=Concatenative |author=[[User:Dolphy]] |year=[[:Category:2024|2024]] |memsys=[[:Category:Stack-based|Stack-based]] |class=[[:Category:Turing complete|Turing complete]] |majorimpl=Will be revealed later |influence=[[Forth]] |f
13:49:25 -!- Thelie has joined.
13:49:48 <esolangs> [[User:Dolphy]] N https://esolangs.org/w/index.php?oldid=143197 * Dolphy * (+63) Created page with "Hello I'm Dolphy. I love math, computer science and philosophy."
13:55:00 <esolangs> [[Olus2000]] M https://esolangs.org/w/index.php?diff=143198&oldid=143196 * Dolphy * (+1) Fix a typo
14:08:21 <esolangs> [[Special:Log/move]] move * Ractangle * moved [[BASE]] to [[BAL]]
14:08:21 <esolangs> [[Special:Log/move]] move * Ractangle * moved [[Talk:BASE]] to [[Talk:BAL]]
14:08:21 <esolangs> [[Special:Log/move]] move * Ractangle * moved [[Talk:BASE/Other esolang implementations]] to [[Talk:BAL/Other esolang implementations]]
14:08:57 <esolangs> [[BAL]] https://esolangs.org/w/index.php?diff=143205&oldid=143199 * Ractangle * (-15)
14:09:22 <esolangs> [[BAL]] https://esolangs.org/w/index.php?diff=143206&oldid=143205 * Ractangle * (-68) /* Commands */
14:10:00 <esolangs> [[BAL]] https://esolangs.org/w/index.php?diff=143207&oldid=143206 * Ractangle * (+49) /* Commands */
14:10:44 <esolangs> [[BAL]] https://esolangs.org/w/index.php?diff=143208&oldid=143207 * Ractangle * (-15) /* Commands */
14:10:58 <esolangs> [[BAL]] https://esolangs.org/w/index.php?diff=143209&oldid=143208 * Ractangle * (+5) /* Hello, world! */
14:12:50 -!- impomatic has joined.
14:16:00 <esolangs> [[BF Joust strategies]] https://esolangs.org/w/index.php?diff=143210&oldid=143195 * Ais523 * (+1539) /* Major Programs */ nyuroki2 topped the hill on 19 August 2017; write a description based on the notes provided by Lymia
14:16:45 <esolangs> [[BF Joust strategies]] https://esolangs.org/w/index.php?diff=143211&oldid=143210 * Ais523 * (+39) /* 2024 */ add a bit of description I missed
14:17:16 -!- tromp has joined.
14:18:38 -!- impomatic has quit (Quit: Client closed).
14:43:05 <esolangs> [[BF Joust strategies]] https://esolangs.org/w/index.php?diff=143212&oldid=143211 * Ais523 * (-336) I restored the broken links to codu.org/eso/bfjoust/in_egobot.hg via rehosting them from a backup (unfortunately, my backup doesn't cover egojsout links)
14:43:39 -!- Thelie has quit (Ping timeout: 260 seconds).
14:48:48 <esolangs> [[Talk:BF Joust strategies]] https://esolangs.org/w/index.php?diff=143213&oldid=132422 * Ais523 * (+1178) /* Dead links */ I fixed some of them, but the egojsout links are more trouble
14:53:51 <esolangs> [[Talk:Around and around, sleeping sound]] N https://esolangs.org/w/index.php?oldid=143214 * ChuckEsoteric08 * (+176) /* Computational class */ new section
14:55:26 <esolangs> [[BAL]] https://esolangs.org/w/index.php?diff=143215&oldid=143209 * Ractangle * (-1210) /* Examples */ will make other examples later
14:55:55 <esolangs> [[BAL]] https://esolangs.org/w/index.php?diff=143216&oldid=143215 * Ractangle * (-1)
14:56:07 <esolangs> [[BAL]] https://esolangs.org/w/index.php?diff=143217&oldid=143216 * Ractangle * (-4)
14:57:30 <esolangs> [[User:Ractangle]] https://esolangs.org/w/index.php?diff=143218&oldid=143073 * Ractangle * (+35) /* Esolangs */
14:58:27 <esolangs> [[BAL]] https://esolangs.org/w/index.php?diff=143219&oldid=143217 * Ractangle * (+199) whoops
14:59:39 <esolangs> [[BAL]] https://esolangs.org/w/index.php?diff=143220&oldid=143219 * Ractangle * (+18) /* Commands */
15:05:58 <b_jonas> I just realized something. A few weeks ago I was thinking about local web apps. So you know how sometimes programs only have a web interface, as in they act as a HTTP server and you interact with them on a browser through a local tcp connection. This is a convenient simple way to make an interface that's portable among systems and somewhat future-proof. For simple things like showing formatted
15:06:04 <b_jonas> documentation this is ideal. But in most cases you need a bit of security, making sure that some other user on the same machine can't just connect to the same TCP stream and execute operations in the server that runs under your user's permissions? One solution would be that the web interface gives a per-connection password that you have to enter to the console launcher. But that's a bit inconvenient.
15:07:07 <b_jonas> Meanwhile, today I was thinking of how firefox doesn't show the actual URL in the URL bar, instead it tries to unescape percent-escaped UTF-8-encoded characters in the path and query string parts.
15:09:09 <b_jonas> That's a misfeature, but you could abuse it to solve the former problem: make the local web app ask the browser to show an URL where the URL has a query string that unescapes to homographs so it always looks like it launches http://localhost:8101/?lllllllllllllllllllllllllllllllll but in fact those aren't all letter l but like ten different percent escaped utf-8 characters that each look like an l in
15:22:02 <esolangs> [[Unique]] https://esolangs.org/w/index.php?diff=143221&oldid=143137 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+12) /* Syntax */
15:22:52 <esolangs> [[Unique]] https://esolangs.org/w/index.php?diff=143222&oldid=143221 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+43) /* Syntax */
15:23:01 <esolangs> [[Unique]] https://esolangs.org/w/index.php?diff=143223&oldid=143222 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+0) /* Syntax */
15:24:02 <esolangs> [[5]] https://esolangs.org/w/index.php?diff=143224&oldid=142897 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+8)
15:30:08 <esolangs> [[/mbif/]] https://esolangs.org/w/index.php?diff=143225&oldid=94356 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+34) /* See also */
15:59:49 <ais523> you could just use lowercase l and capital I
16:00:43 <ais523> although I'm not sure why you want the URL to be hard to read? is this a mitigation against shoulder-surfing attacks?
16:03:47 <b_jonas> there are existing methods to open a URL of my choice in the user's favorite browsers, but no easy way to pass a hidden POST parameter to that
16:04:07 <b_jonas> of course it would be easier to just use a long URL that hopefully shows truncated in the URL bar
16:04:42 <b_jonas> l is probably not the best choice, some other homograph group might be better
16:05:50 <ais523> I think you can make it secure without the homographs: open a randomly generated unique URL and then have that immediately POST a random string back to the server
16:06:49 <ais523> if someone tries to copy the URL they won't get in ahead of the legitimate connection, and the POSTed string won't be visible onscreen anywhere
16:07:04 <ais523> from then on it can be used for the browser and server to authenticate each other
16:07:40 <b_jonas> yeah, but that sort of depends on a race condition
16:08:00 <b_jonas> probably good enough, especially if the URL is long so likely truncated
16:08:20 <ais523> it's not really a race condition if one side of the race is known to be much faster than the other
16:08:36 <ais523> the browser won't even display the URL on screen until it starts to load the page
16:08:57 <b_jonas> though I'd make the server generate a cookie instead of the client generate a random string, but that's not really important here
16:09:28 <ais523> no, that increases the window for the race condition
16:09:54 <b_jonas> "known to be much faster than the other" => I've had my firefox freeze for long enough times that it's not that clear cut, though it probably wouldn't freeze between displaying the URL and loading it
16:10:10 <ais523> server is making the first meaningful connection here, isn't it?
16:10:17 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
16:12:06 <b_jonas> another method could be to have browser-specific solutions for the most popular browsers, and require the user to copy a short string from the loaded browser page to the launcher for everything else
16:12:26 <b_jonas> even the browser-specific solutions could break for unusual setups of cousre
16:13:07 <ais523> on many OSes the launcher won't have a functional UI of its own
16:20:30 <b_jonas> ais523: true, but in the case I'm thinking the UI can be either a command-line program running in a terminal, or you run teh command-line program again with some the identifying string as an argument
16:20:59 <b_jonas> I mean in the former case it would read the identifier as input from the terminal
16:30:21 -!- tromp has joined.
17:08:14 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
17:19:13 <esolangs> [[Olus2000]] M https://esolangs.org/w/index.php?diff=143226&oldid=143198 * PythonshellDebugwindow * (+40) Distinguish confusion
17:28:10 <esolangs> [[Special:Log/move]] move * Ractangle * moved [[BASE/Other esolang implementations]] to [[All in one]]
17:28:10 <esolangs> [[Special:Log/move]] move * Ractangle * moved [[Talk:BASE/Other esolang implementations]] to [[Talk:All in one]]
17:28:51 <esolangs> [[BAL]] https://esolangs.org/w/index.php?diff=143231&oldid=143220 * Ractangle * (-106) /* Other implementations */
17:33:06 <esolangs> [[All in one]] https://esolangs.org/w/index.php?diff=143232&oldid=143227 * Ractangle * (-2331) Replaced content with "'''All in one''' is an OSIC created by [[User:Ractangle]] that works like this: The first argument choses a commend Everything else is the commands arguments"
17:33:18 <esolangs> [[All in one]] https://esolangs.org/w/index.php?diff=143233&oldid=143232 * Ractangle * (+2)
17:33:32 <esolangs> [[All in one]] https://esolangs.org/w/index.php?diff=143234&oldid=143233 * Ractangle * (+9)
17:47:46 <esolangs> [[User talk:Gggfr]] https://esolangs.org/w/index.php?diff=143235&oldid=143138 * Gggfr * (+126) /* unique's relationship with forte */
17:54:45 -!- ipadwwwww has joined.
18:04:29 <esolangs> [[Talk:Andrew's Programming Language]] https://esolangs.org/w/index.php?diff=143236&oldid=141690 * Gggfr * (+141)
18:06:49 -!- tromp has joined.
18:08:23 <ipadwwwww> BUT you can also apply arithmetic cuz the number of functions is just the number of functions inside.
18:08:53 -!- ipadwwwww has quit (Quit: Client closed).
18:09:14 <korvo> Ah, they were too fast. I was going to ask how eta-equivalence would work.
18:10:37 -!- ipadwwwww has joined.
18:10:55 <ais523> ipadwwwww: <korvo> Ah, they were too fast. I was going to ask how eta-equivalence would work.
18:11:24 <ais523> on another note, I've made a start at getting the BF Joust page back into order, having found all the missing programs from a backup I took a while ago
18:11:59 <ais523> but there's currently no way to have working trace-and-animation links, because zemhill only does those for programs on the hill and egojsout isn't running anywhere else
18:13:14 <ais523> just adding the simple example program from the egobot hill as an option in the dropdown would be helpful for that – it'd also be helpful if there were a way to compare programs from different hill iterations (which there probably is, but it isn't clear from the UI)
18:13:48 -!- Sgeo has joined.
18:13:50 <ais523> ipadwwwww: I've had some experience trying to design "functional, except the functions have non-function properties too" esolangs, it tends not to work well or is at least difficult to do correctly
18:14:05 <ais523> e.g. in Underload, a stack element can be interpreted either as a function or as a string, and this makes it hard to compile
18:14:17 <ais523> it's possible but it's very inelegant
18:14:26 <ais523> and is probably one of the worst parts of the language
18:14:34 <ais523> (although, it does make it fun and easy to write quines)
18:15:11 <ais523> I feel like I know most of the conversion/equivalence rules for lambda calculus but forget which one is which
18:15:27 <b_jonas> ipadwwwww: eta conversion is when alligators are like chameleons, changing color
18:15:58 <b_jonas> https://worrydream.com/AlligatorEggs/
18:16:27 <ais523> OK, eta-equivalence is the rule that two functions are considered equal/equivalent if they give the same outputs when given the same inputs
18:16:37 <ais523> (I knew the rule, just had to look up which rule it was specifically that was named eta)
18:17:08 <ais523> in this case, that has a fairly clear generalisation to "two functions are equal if they have the same outputs given the same inputs, and the same numerical values"
18:17:23 <korvo> ipadwwwww: Eta-equivalence is that you can take any lambda expression (call it f) and replace it with \x.f(x).
18:17:27 <int-e> \x. M x = F, x not free in M; related to extensionality
18:17:50 <korvo> So it makes me wonder what you mean by "the number of functions inside", assuming that you're counting lambda-binders.
18:18:17 <b_jonas> ais has a point, alligators behaving like chameleons is *alpha*, not *eta*
18:18:19 <ais523> an alternative way to generalise it is to have a sort of special argument that you can pass to a function to make it return its numerical value; this goes spectacularly wrong if you try to implement it or reason about how it works, but there might yet be some way to make it work (I haven't found it yet though)
18:18:22 <int-e> s/F/M/ in what I wrote (editing error)
18:18:57 <ais523> int-e: do you mean that x *is* free in M/F?
18:19:16 <int-e> ais523: no. There's a free x *after* M
18:19:28 <ais523> I understand what you were saying but misremembered what "free" meant
18:19:36 <korvo> Yeah, that word "extensionality" int-e used is important. Do you want functions to *only* be defined by their behaviors, or by their behaviors *and* their source code?
18:19:40 <int-e> well, "free" - it's bound by the outer lambda of course, but in the body it's free
18:19:46 <ipadwwwww> im so confused. why wouædnt eta stuff work
18:19:52 <ais523> it means "used but not defined", whereas I was interpreting it as "unused"
18:20:56 <HackEso> Can't open perl script "print(0+sub{}) ": No such file or directory
18:21:18 <ais523> OK, I understand why that has to return a number, because you cast it to a number
18:21:31 <korvo> ipadwwwww: I'm not saying it wouldn't work. I'm just trying to understand. Maybe this is very clear in your mind, but I can't imagine it at all.
18:21:31 <ais523> I don't understand why sub references do that when you cast them to a number, though
18:22:03 <ais523> I guess it's references in general, and they cast into their memory address?
18:22:10 <ais523> why would Perl even expose that as a primitive?
18:22:28 <ais523> (I'd expect it to exist on CPAN somewhere, but as a behaviour of 0+?)
18:22:42 <ais523> `perl -eprintf"%x",(0+\$_)
18:22:55 <ais523> that does look a lot like a memory address, they often start with 55 on Linux, IIRC
18:23:13 <ipadwwwww> ok. so you have normal expression but they have a value inwhich its equal to the number of lambdas. then you can modify this number to return new functions…does it make sense now korvo
18:23:38 <korvo> ipadwwwww: I guess let's look at some examples. Would \x.x and \x.\y.xy have the same number?
18:24:17 <ipadwwwww> if you give it an input before operations
18:24:31 <ipadwwwww> lets say x was identity for the second function
18:24:45 <korvo> Hm. Is that even decidable? I'm genuinely unsure.
18:24:54 -!- Thelie has joined.
18:25:43 <ais523> korvo: I'm genuinely unsure whether it's even well-defined or not
18:28:12 -!- Thelie1 has joined.
18:28:13 -!- Thelie has quit (Client Quit).
18:30:10 <ipadwwwww> ill just make a base in like google docs then you can see it ig
18:31:04 <b_jonas> ais523: partly for historical compatibility with old perl, the origins probably go back to ancient C which allows you to cast any pointer to a number; partly so you can use that to make a hash keyed by the addresses of references (there's a module in core to make that easier now)
18:31:29 <ais523> even modern C lets you cast any pointer to a number, you just might not like the reuslts
18:35:04 <ais523> fwiw, I'm very against languages letting you do that sort of thing just because it's easy, because it creates a compatibility nightmare down the line
18:35:22 <ais523> e.g. in Rust you can cast an
18:35:29 <ipadwwwww> i have a deep rooted problem with haskell
18:35:40 <b_jonas> `! c int f(unsigned long v) { printf("f=%lu\n", v); return 0; } int main(int c, char *v[]) { return f(f); }
18:35:55 <ais523> * cast a shared reference to a pointer, and even though usually you don't care that the pointer references the specific object it's referencing rather than a copy, the semantics do guarantee that, and that blocks optimisations
18:36:11 <korvo> ais523: Worse, it creates a weak Sapir-Whorf effect: many folks believe that if you cannot turn a pointer to a number or vice versa, then you're unable to program a machine at the lowest level.
18:36:42 <b_jonas> ais523: yes, and perl lets you convert a reference to a number in more circumstances, eg. in C you can't just write p/2 to get a number from a pointer, you need either an explicit cast or an assignment or pass as function argument or return from function to cast
18:36:44 <ais523> korvo: the truth is more like "even if you can't turn a pointer to a number or vice versa, you're unable to program a machine at the lowest level"
18:37:49 <ais523> int-e: do those two uses of . even technically conflict with each other?
18:38:30 <b_jonas> ais523: anyway, yes, even if exposing the address is useful, it would have made better for perl to require an explicit call for this, so it's there only for compatibility probably
18:38:38 <korvo> ais523: Exactly! I am so lucky that lvh pushed me to learn Forth in my 20s. Definitely helped me be less of a bro.
18:38:43 <int-e> ais523: Hmm I only see one use of .
18:38:44 <ais523> I will say that being able to do an untagged union is helpful for low-level programming, and being able to do a pointer-to-int conversion is one way to do that, but there are alternatives
18:38:57 <ais523> int-e: the other one being the \x. rather than \x-> syntax
18:39:03 <ais523> that ipadwwwww was discussing
18:39:32 <b_jonas> korvo: hmm, do people believe that?
18:39:33 <ais523> korvo: did you see my fizzbuzz? that wasn't quite the lowest level of abstraction possible, but it was close
18:39:41 <ais523> b_jonas: yes, they are wrong but it's a common belief
18:39:48 <int-e> oh you mean, would the syntax become ambiguous if we used . instead of -> ...hmm.
18:40:15 <korvo> What I want to see more of is intrusive tagged unions, e.g. hardware registers where part of the register is a tag and the other part is tag-dependent. I can't think of any languages that elegantly handle this.
18:40:18 <ais523> I guess it's only ambiguous if (.) can be a type constructor
18:40:34 <ais523> and I don't know Haskell well enough to know whether it technically could be or not
18:40:42 <ais523> (it certainly *shouldn't* be)
18:40:43 <int-e> \0.0.0 could be either \0.0 -> 0 or \0 -> 0.0 though :P
18:40:57 <ais523> oh, the float.0 ambiguity, Rust has that one too
18:41:17 <ais523> fortunately, integer literals are not tuples so it's an easy one to decide the correct resolution for
18:41:44 <ais523> ipadwwwww: some languages let you override the basic definitions, e.g. in case you are implementing the standard library
18:41:56 -!- ipadwwwww has quit (Quit: Client closed).
18:52:14 <korvo> b_jonas: Yeah. Like, the Rust example is good, but it happens *every time* somebody tries to write a kernel. House is a Haskell kernel with a special monad they called H; H is just IO but with the ability to poke and peek registers and allocate memory from an MMU.
18:53:07 <ais523> is there a reason the regular IO monad can't do that?
18:53:26 <korvo> Bootstrapping Forths usually start from poke and peek; I think the classic three-instruction booter is poke, peek, and jump. Poke and peek were how syscalls were done on consumer PCs before OSs, and depending on how you feel about software interrupts they're how syscalls are done today too.
18:53:53 <korvo> ais523: Not really. But that's the sheer reach of the meme.
18:54:03 <b_jonas> ais523: it's probably reasonable to notate your kernel mode capabilities with a different tycon than the more restructed user mode ones
18:54:13 <ais523> oh, on modern x86-64 software interrupts are obsolete as a system call method because they're too slow (although they do still work IIRC)
18:54:42 <ais523> b_jonas: hmm, I guess the choice of monad is one way to do capabilities, although it's a bit of a weird way to do it
18:55:11 <korvo> The Objective-Smalltalk guy has a series of rants on this too; he's upset with what he sees as "the gentle tyranny of the call-return paradigm", and I've chatted with him about how this goes all the way to the hardware, making it an example of an even deeper meme than pointer ~= int.
18:55:34 <ais523> nowadays there is a specific instruction for doing syscalls that just does the bare minimum to make them work (it even clobbers two registers to make the implementation faster, which interrupt handlers can't do for obvious reasons)
18:56:11 <korvo> Upcoming hardware is going to have to fight this battle too. The Mill doesn't exist, but CHERI and RISC-V do. ARM also has encrypted/authenticated pointers, which are a nasty nasty hack but also break pointer ~= int.
18:56:14 <ais523> korvo: I was thinking about that for a while, and realised that part of the problem is that call/return often genuinely is the best solution
18:56:38 <ais523> also, I'm disappointed that the Mill still doesn't exist, I thought it was further along than that
18:57:32 <korvo> ais523: Is it? I'd compare specifically with event loops, which don't use the stack quite like call/return does, and also with continuation-oriented stuff that never returns. I know that all of our current implementation techniques reduce to call/return, but I think that that's still a hardware quirk.
18:57:39 <ais523> I had my own idea about how to make a better register-like abstraction which is basically the opposite of what the Mill does – each instruction specifies that its result should be passed to the instruction that runs *n* instructions later (rather than instructions taking their argument from *n* instructions earlier)
18:57:49 <esolangs> [[User:HammyHammerhead]] https://esolangs.org/w/index.php?diff=143237&oldid=136086 * HammyHammerhead * (+0) Censor
18:58:14 <ais523> korvo: well, there are plenty of cases where it isn't too
18:58:22 <ais523> but it isn't like goto or int/pointer which are nearly always the wrong solution
18:59:14 <korvo> As of this year, Mill's status is that it's a VM target which isn't open-source yet: https://millcomputing.com/topic/yearly-ping-and-see-how-things-are-going-thread/ So it's not quite where RISC-V is, but not out of the game.
18:59:24 <int-e> ais523: https://wiki.osdev.org/System_Calls#Trap
19:00:00 <ais523> int-e: isn't that even slower than a software interrupt?
19:00:39 <int-e> pretty sure it was chosen because it was a few cycles faster on 32 bit Pentium, somehow.
19:00:44 <korvo> ais523: I might be lost in maths. I had an idea over the summer: the typical register ISA looks like a multicategory if we restrict to straight-line code, and I can extend this to most conditional code too. Only three constructs can't be handled: computed jump, call, and return.
19:01:16 <korvo> If the hardware had an implicit event loop, or an implicit continuation-passing mechanism, then it'd be a perfect fit.
19:01:39 <ais523> how do you handle infinite (or potentially infinite) loops?
19:02:31 <korvo> The multicategory only has total computable arrows.
19:04:10 <ais523> that would make the hardware kind-of useless, if it can't run functions that aren't provably total?
19:04:42 <korvo> This is the ideal of Actor systems, FWIW. Each actor has a very simple small behavior which always returns quickly, and the event loop stitches them together into a Turing-complete system. Thousands of actors per CPU, each one less than a KiB.
19:04:44 <b_jonas> "it even clobbers two registers to make the implementation faster, which interrupt handlers can't do for obvious reasons" => https://esolangs.org/wiki/Apollo_Guidance_Computer disables interrupts while the accumulator has an overflow
19:04:45 -!- Thelie1 has quit (Ping timeout: 276 seconds).
19:04:57 <b_jonas> because it would be hard for the interrupt handler to save and restore it properly
19:05:15 <b_jonas> sounds like they designed themselves in a corner there
19:05:26 <ais523> korvo: ah, you have non-totality in the event loop itself
19:06:08 <korvo> ais523: Sure. I defeat such memes with reduction to physics. In this case, a CPU's clock constrains how much computation happens per operation, so the CPU already is like an infinite event loop which executes a series of total-computable actions.
19:06:39 <korvo> Yes, exactly. Or the continuations are set up such that a letrec can be built, and so general recursion is possible; that's how the Reduceron computes IIRC.
19:06:59 <ais523> I guess many of my thoughts on the matter are related to thinking that the independent-threads-of-execution model may be wrong or at least inefficient; I'm more of a fan of manual event loops
19:07:21 <ais523> continuations are more interesting, but seem about as low-level as call-return
19:07:51 <korvo> Have you seen microkernels with fast message passing? The common example today is seL4, but L4 or QNX are also good examples.
19:08:09 <ais523> I wrote a VM for combinatory logic a while back which describes the state of the program as three combinators (let's call them a, b, c) that represent an evaluation of the function c(a(b)), but all three are always fully reduced
19:08:36 <korvo> In these systems, if an actor promises to handle a message very quickly and synchronously, then the message can be passed *in registers* and the actor is entered *as a call*. So call/return becomes an *optimization* on top of message-passing semantics.
19:08:42 <ais523> korvo: oh, it's more that I'm thinking about "are these things actually supposed to be fully independent of each other, or not?"
19:09:01 <ais523> I wasn't thinking about the implementation, more about the semantics
19:09:08 <korvo> They start out independent and isolated, and then (to borrow the Go meme) they share memory/resources by communicating.
19:10:09 <esolangs> [[Talk:Delta Relay]] N https://esolangs.org/w/index.php?oldid=143238 * HammyHammerhead * (+0) Created blank page
19:10:36 <ais523> I guess that my mental model of an event loop is that we have a number of tasks/threads/actors/whatever that are each trying to do something, but sometimes they get blocked because they want to perform a blocking action, and sometimes they are not currently blocked, but paused because they were blocked and haven't been explicitly unblocked yet
19:11:26 <korvo> Sure. That model has locks, right? Or some similar resource which supports contention.
19:11:31 <ais523> and that a good event loop works by running until some or possibly all of the threads are blocked, either sequentially or in parallel, then does some I/O and determines which threads got unblocked by it
19:11:55 <ais523> yes, if the threads need to communicate they need some sort of way to contend with each other, and the event loop resolves that
19:11:56 <int-e> ais523: Oh there's context missing. On modern L4, `lock nop` is how you query the base address for the page with all the actual system calls, which presumably use SYSCALL/SYSENTER.
19:11:59 <esolangs> [[Talk:Delta Relay]] https://esolangs.org/w/index.php?diff=143239&oldid=143238 * HammyHammerhead * (+143) /* Not to be confused... */ new section
19:12:30 <esolangs> [[Talk:Delta Relay]] https://esolangs.org/w/index.php?diff=143240&oldid=143239 * HammyHammerhead * (+97) /* Not to be confused... */
19:12:44 <ais523> but what I'm thinking about is, is it actually always correct for the threads to continue running after they become blocked?
19:13:07 <ais523> like, in many cases, if they haven't done much work, it makes more sense to discard the work and restart them later, rather than trying to capture their current state
19:13:14 <korvo> My mental model doesn't have locks. Instead, it has explicit backpressure represented by unfulfilled heap allocations (promises/futures). It runs until there's no more messages to deliver.
19:13:17 <ais523> or if there's a deadlock, it's impossible to run both deadlocked threads to completion, one of them has to back out
19:14:06 <ais523> it's possible to imagine a purely revert-based model in which threads start running, and if they discover they're blocked, they undo everything they've done so far
19:14:26 <ais523> and the event loop records the fact that they were blocked, and what they were blocked on, and restarts them once they should now be possible to run
19:14:47 <ais523> that probably isn't very efficient, but it's very appealing from the "ease of programming" point of view, as long as you're not communicating with a system you couldn't easily revert
19:15:21 <ais523> (of course, this means that you need a set of "I/O rules" that actually make it possible for them to gather all the information they need to run to completion in one go)
19:15:33 <korvo> Believe it or not, this is what happens in Cliff Click's JVMs, from Hotspot to Zulu, and it's apparently a winning strategy. You do incentivize your users to not make FFI calls, which can be thousands of times more expensive than native, runtime, or user calls.
19:15:50 <korvo> Your model is like a JVM.
19:16:10 <int-e> "They should probably have used the "UD2" instruction, since it is defined for this purpose." -- but compilers emit UD2 in some cases for code that is supposed to be unreachable and you *really* want that to trap properly instead of executing a system call and running whatever code comes next.
19:16:22 <ais523> there are UD1 and UD0, too
19:16:36 <ais523> I think UD1 might be the one that's most commonly used for syscalls, and UD0 might be undocumented?
19:16:38 <korvo> My model is like E or Monte, but also like JS in a browser or "RPC" packets in a modern cloud app. The difference is that my model is cloud-native; it was intended to be stretched over multiple machines, not just SMP.
19:16:45 <ais523> (the "2" is probably a clue)
19:17:48 <ais523> ooh, UD0 *is* documented, but different processors differ in how many bytes long it is – that's why it's discouraged
19:17:57 <ais523> (it must be one of the very few instructions for which its byte length usually doesn't matter)
19:18:49 <ais523> the manual says that it matters if the third byte of the instruction is on an unloaded page, because that influences whether you get a page fault or an undefined opcode trap
19:19:19 <ais523> but, I guess that usually wouldn't matter either, even if the kernel didn't special-case it!
19:19:43 <korvo> ais523: Oh, an example of my model in production might be the classic iPods. These had two ARM processors. One processor was dedicated to MP3 decoding and the other ran the UI. They only communicated through a scratchpad and mailboxes; they did not share a coherent view of RAM.
19:20:32 <ais523> I don't think my model has a coherent view of RAM either
19:20:39 <korvo> But yeah, message-passing is typically more expensive than direct call/return. It's more expensive than anything else; it has to reify the arguments so that they can be serialized or forwarded, and that's always going to be an expensive prologue.
19:21:00 <ais523> locking doesn't necessarily have to be "I want exclusive access to this memory address", it's more "I want exclusive access to this value" – there's no logical reason why locking can't move a value
19:21:43 <ais523> in fact, I recently realised that, e.g., locking a database row is equivalent to temporarily deleting the row from the database, with a marker specifying not to place another row there yet
19:22:36 <b_jonas> that's like the SNES, which has two CPUs with separate RAM, and they only communicate through 4 to 8 registers
19:23:04 <b_jonas> by registers I mean byte values mapped into both of their memory space
19:24:06 <b_jonas> 4 to 8 because it's 4 registers that kind of have separate values in the two directions, but not quite, they behave in some weird way that I don't understand if you try to use one in both directions
19:24:17 <korvo> Another good example, yeah.
19:24:49 -!- Everything has joined.
19:26:00 <ais523> OK, I guess I've clarified my view to: I dislike message-passing because it means that the various threads need to be aware of each other and who they're passing messages too, whereas concurrent programs are much easier to write, and much more reliable, if the threads all work correctly regardless of what other threads exist and what they are doing
19:26:12 <ais523> *who they're passing messages to
19:26:24 -!- X-Scale has joined.
19:26:54 <korvo> ais523: Yes. In our parlance, you are in favor of "global mutable state", and as you say, it's fine as long as the program is correct under that assumption.
19:27:59 <ais523> I guess I would say that I'm in favour of, in situations where mutable state has to exist, programming techniques that mean you don't need to make assumptions on what other programs, or other parts of the same program, may be doing with that state
19:27:59 -!- Thelie has joined.
19:28:05 <korvo> Most actor systems are going to have some sort of ban on global mutable state. Any kind of mutation is going to be local to individual actors, and some systems might require you to serialize your closure at the end of your action, so that you can't leave a mutation half-done.
19:28:46 <ais523> over the last few weeks I have been actively trying to work out what the correct scope for mutable state is, and I haven't reached any final conclusions yet
19:29:11 <korvo> It'd have to be other parts of the same program, because with global mutable state, *any other program* can stomp your program's state.
19:29:41 <ais523> although my current view (which might well change) is "it could be very local and you can encapsulate it in a call-return type of way without the rest of the call stack ever seeing it; and the rest of the time, global is *usually* correct but not always"
19:30:12 <ais523> korvo: only if there aren't enforced rules on what it does with it
19:30:21 <ais523> I think of reading from a file as a good example
19:30:45 <ais523> this is something that's hard to do efficiently and correctly in languages like Rust – currently, if you memory-map a file in Rust, you get UB if some other process writes to it while you have it mapped
19:31:01 <esolangs> [[Project Euler/16]] https://esolangs.org/w/index.php?diff=143241&oldid=137144 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+23) /* Implementations */
19:31:21 <ais523> but, say you place a mandatory lock on it, or a lease, now you can make your program correct regardless of what other programs might to do it (e.g. by abandoning your current computation if you are requested to abandon the lock)
19:31:30 <korvo> ais523: Okay. So what's the big difference between breaking the whole machine up into an OS enforcing rules on programs, and breaking a whole program up into an event loop enforcing rules on actors/objects/etc?
19:32:14 <ais523> I'm not sure there's a *big* difference; the main difference seems to be that mutable state often feels like something that wants to persist beyond the program
19:32:48 <korvo> Sure, but only at the pleasure of the OS. Similarly, any state that wants to persist beyond an individual actor needs to be communicated via the event loop.
19:32:52 <ais523> like, the main areas of mutable state I've identified are a) algorithms that use mutable state, which is generally neatly encapsulated inside one function/thread, and b) things that could logically be very persistent, even across reboots
19:33:10 <ais523> there are almost certainly others and examples would be helpful
19:34:19 <korvo> Oh, reboots clear all mutable state, in this framing. Persistence is a terminus for mutation. So (b) kind of fades to an opinion rather than something essential.
19:34:47 <ais523> ah; I think that might be a genuine difference of opinion
19:35:11 <ais523> in a way, if you have any mutable state that *isn't* persistent, either a) you didn't need it or b) your program is incorrect if someone kills it / cuts the power / reboots the machine while it is running
19:35:23 <korvo> A file isn't really mutable; each syscall towards it results in a new serialized state, and certainly the underlying disk is usually block-at-a-time. In contrast, SysV/POSIX tools like message queues, shared-memory segments, etc. are global mutable state.
19:35:47 <korvo> Oh, it's always (a). Mutation is always an optimization.
19:36:47 <korvo> Actor systems are encouraged to be transactional and to keep all important state at message boundaries. For example, my raytracers only lose a few pixels of progress if they lose rendering clients. (Losing the rendering server, of course, loses the entire frame. I'm not Pixar.)
19:37:27 -!- tromp has quit (Read error: Connection reset by peer).
19:37:47 <ais523> but when I think about the programs I want to write, the main options are a) computer games, in which the save file effectively acts like mutable state and most of the games I want to write want to update it continuously as the user plays; b) compilers/build systems, which want to avoid redoing work as much as possible, so the information about what they've done so far is persistent
19:38:54 <ais523> anyway, I guess my main objection is that if I have a mess of actors, and a backup of the messages they were passing around, that is much less usable for unrelated programs than a file in a clearly-documented format would be
19:39:57 <korvo> Sure. Smalltalk images are a practical example, and they're really only useful for resuming progress, not for outputting permanent artifacts.
19:41:40 <korvo> Well, actually, thinking more, a backup of all in-progress messages is equivalent to a core dump, not a nice output. So maybe we're not being apples-to-apples about this.
19:42:23 <ais523> right, my viewpoint is not that the two things are comparable, but that they aren't comparable and that this is a problem with Smalltalk-alikes
19:43:10 <ais523> one really big problem with Smalltalk images, which presumably isn't a problem for the actor images / core dumps, is that they mix code and data, making it hard to use the code you've written on a different set of data, and making it hard to version the two separately
19:43:18 <korvo> On (b), Monte's reference implementation uses Nix and supports per-module incremental builds. For the past two decades, it's purely been an engineering problem. Perhaps there's the meta-problem that we aren't teaching capability theory, which directly leads to content-addressed storage; but git was invented without it.
19:44:20 <ais523> korvo: OK, I'll agree that it makes sense to build a declarative / pure / immutable build system on top of some underlying library that handles the details of optimising it into something that works with mutable state underneath
19:44:45 <ais523> the problem being, that I'm more thinking about how to write the library beneath rather than the program on top of it
19:44:50 <korvo> Right. E-style actors are distinguished by *safe code loading*. Code can only be passed around if it can be serialized, which involves a metaintepreter examining the code's AST and building an equivalent AST which is safe on the wire.
19:45:29 <ais523> so Java has a mechanism for this sort of code passing
19:45:41 <ais523> involving serialised code on the wire, with sandboxing and safety checks
19:45:46 <ais523> it was heavily involved in a previous job of mine
19:45:48 <korvo> Smalltalk totally fails at this. Mark Miller's thesis explains that Java fails at this too, even though they explicitly tried to make code-loaders safe. The problem is that the ambient authority, including global state, included in Java's code-loading is too much.
19:46:13 <ais523> ah good, so you already know why it doesn't really work in Java and I don't have to explain, makes life easier :-)
19:46:36 <korvo> Right, JOSS or whatever. Hilarious source of security vulnerabilities. Got familiar with it when reverse-engineering MineCraft.
19:47:39 <korvo> Anyway, that doesn't happen here. Instead, when the code first tries to be passed on the wire, the E/Monte runtime inspects it, directly reading its AST and private state without calling into it. If the code can be safely serialized, then that's done; otherwise, a reference to the code object is put on the wire.
19:48:01 <ais523> the more interesting question is whether, if you put enough restrictions on this sort of thing to make it actually safe, the result is useful for anything
19:48:17 <korvo> E-style message-passing semantics ensure that a reference to the code will be just as good as the code itself; the code-passing and code-loading is ultimately an optimization.
19:48:31 <ais523> I am not sure on the answer to that; I think maybe it could be, but I also think that attempts to do that are more likely to have subtle mistakes than to be entirely correct
19:49:35 <korvo> Great question! That catches us up to when I entered the scene. The point of Monte is to show that it's possible to write a Monte compiler, a raytracer, a distributed worker, an HTTP server, a TUI app, and a bunch more stuff.
19:50:33 <korvo> Monte sucks and I'm one of only two people to seriously work in it. But also, I can't think of something that can't be done with it; I put in five years of using Monte instead of Python. So I'm confident that it's possible to be safe, tamed, and still shipping.
19:50:51 <korvo> More practically, seL4 exists and I hear it's in cars and planes and satellites and other fun stuff.
19:53:25 <esolangs> [[Category talk:Turing complete]] https://esolangs.org/w/index.php?diff=143242&oldid=108290 * Xff * (+108)
19:53:35 <korvo> (And anticipating the next question, Monte's reference implementation spanks Python's reference implementation on apples-for-apples benchmarks like dhrystone.)
19:54:36 <ais523> oh no, I wasn't planning to ask that, basically everything beats Perl/Python on performance unless they call out to a library written in some other language
19:54:42 <ais523> I think maybe INTERCAL is slower? but I'm not sure
19:54:51 <korvo> This is where Cammy came from. CAM-E, a Categorical Abstract Machine for E-style actors. Each actor would run a Cammy expression upon an incoming message. I haven't bothered building up the big impressive parts because nobody cared when I built them last time.
19:55:36 <korvo> But ultimately I think that we needed a code language. The kernel of E was abstracted into Data-E, which would eventually become JSON. Great for data, but terrible for code.
19:56:52 <korvo> And ECMAScript failed to be the future for us. WebAssembly *is* the future; it's capability-safe and isolated by default. But actually doing stuff with WASM sucks too.
19:57:38 <ais523> WASM is *part of* the future, I think – but it feels like one layer in a big software stack and it may be one of the more easily replaceable layers
19:57:59 <korvo> Like, for example, there should be a nice easy compiler from Cammy to WASM. It's just S-expressions, right? But there's no good way to map Cammy's curry/uncurry/apply onto WASM's call/return.
19:58:01 -!- PCWWWWW has joined.
19:58:27 <korvo> PCWWWWW: Welcome back! I just came full circle. You should consider setting up an IRC bouncer at some point. Not right now, of course.
19:58:36 <esolangs> [[Empty]] https://esolangs.org/w/index.php?diff=143243&oldid=142917 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+97) /* Modulo */
19:58:59 <korvo> ais523: Thanks for listening to my rant. As you can tell, it's a greatest hit. I'm gonna get lunch.
19:59:03 <ais523> korvo: and this is because WASM is at its heart an imperative VM that is supposed to easily capture operations from imperative assembly languages
19:59:17 <PCWWWWW> also any good pun for monads plz. im making an esolang i need a pun and im bad at puns
19:59:36 <korvo> PCWWWWW: An IRC bouncer is an IRC client that is always running on a cloud server or VM somewhere. Your IRC client on your phone would connect to the bouncer. The effect is that the bouncer collects all of the messages since your last connection.
19:59:59 <ais523> korvo: I just use the logs for that – I've never been a huge fan of bouncers
20:00:28 <ais523> the obvious pun on "monad" is that "monad" can refer to either the category-theory concept (which is used in a slightly modified way in Haskell), or "a function that takes one argument"
20:00:43 <ais523> unfortunately, despite being obvious, this pun often doesn't lead to any good jokes
20:00:45 <korvo> ais523: Right. And also a modular system for incorporating other folks' code safely (safe code loading!) And also an interop for JS and the browser with GC handles. And also have syscalls for replacing Docker containers. And on and on. I want a refund on this future.
20:02:03 <PCWWWWW> igot such a stupid joke/pun
20:02:36 <PCWWWWW> ...banosh me from ths realm plz
20:04:00 <ais523> I've been in IRC channels where an op would kick you out of the channel as a joke for saying that, because the opportunity would be too good to pass up – but I tend not to like that moderation style, joking with moderation tools is too easy to misinterpret and can leave people feeling like the rules don't matter
20:04:46 <korvo> PCWWWWW: Do you know what a Kleisli category is yet? (Might have spelled that wrong.) Every monad gives rise to such a category. Could be a more useful way to express your language as well.
20:05:09 <PCWWWWW> also i should prop say what my esolang is
20:05:28 <PCWWWWW> that can be recursie'and then you have an operator that returns the monad of that
20:05:54 <PCWWWWW> you have one built in which is a category of two things
20:06:11 <korvo> Let M be a monad on some category with arrows like f : X → Y. The Kleisli category's arrows are like M(f) : X → M(Y); they're like the original arrows, but they "carry effects" or "carry the monad" of M.
20:06:16 <PCWWWWW> connect to themselves and each other
20:06:55 <korvo> Oh, Leibnitz's monads, I see. Sorry. I thought you were talking about category theory.
20:07:36 <PCWWWWW> technically we *are* but yea
20:07:48 <PCWWWWW> im talking about likethe function monads
20:08:34 -!- craigo has joined.
20:11:30 <ais523> I don't think I have an opinion about this
20:11:50 <PCWWWWW> aww:( but im horrible at choises
20:12:03 <ais523> naming things is one of the hardest problems in computer science, but often solving it incorrectly is not a disaster
20:12:13 <korvo> I think that you should develop this concept more without giving it a name.
20:12:41 -!- X-Scale has quit (Quit: Client closed).
20:12:51 <PCWWWWW> wait wat korvo we are talking about category theory
20:13:07 <korvo> I have a related concept, giving an algebra over opetopes (fancy category-like things, don't worry about it) but I have a bunch of open questions that I don't know how to resolve.
20:13:17 <korvo> No name for the concept yet. It's just not clear enough.
20:13:37 <ais523> there are esolangs that took me years to figure out the details of
20:13:44 <ais523> https://esolangs.org/wiki/Delta_Relay for example
20:13:59 <ais523> I named it after I'd worked out the details, and only spent about a day on the name (which is more than usual)
20:14:48 <korvo> PCWWWWW: Well, I wasn't sure if you were. I don't get the feeling that you know what a monad is yet. And some people take decades to understand what they are, usually because they're not actually reading the definitions.
20:14:57 <PCWWWWW> its just the (which is more than usual)
20:15:33 <ais523> korvo: so I recently came up with something which I suspect isn't a monad, but it acts a lot like one, and I am still trying to figure out exactly what it is and what the rules are
20:15:33 <PCWWWWW> korvo: well isnt a monad of/in X the moinoid of endofunctors in X
20:16:11 <korvo> PCWWWWW: Sure. More specifically, *any* monoid of endofunctors is equivalent to a monad, right?
20:16:43 <PCWWWWW> just if monad is a function then its that way
20:17:01 <ais523> but I feel like I don't have a complete grasp on all the details of the definition yet
20:17:02 <PCWWWWW> and a moinoid is a category with a id element and a totl operator
20:18:45 <zzo38> You had mentioned WebAssembly. I think there are some good ideas with WebAssembly such as being capability-safe like you describe, and that it cannot do I/O by itself, and using a binary format rather than text like JavaScript, also I think is a good idea, but also it has some bad ideas and I think it is badly designed in many ways, too.
20:18:52 <PCWWWWW> in this esolang the id element is just an object with no morphisms other than an endomorphism
20:19:09 <PCWWWWW> and the total operator just returns the first endofunctor
20:19:14 <korvo> ais523: It could be a generalized monad. Monads are the simplest examples of 2-arrows; they can get very fancy. It could also be some sort of algebraic gadget that isn't quite monadic but still obeys some laws. Or maybe it's not well-described categorically.
20:19:30 <PCWWWWW> also how did we get to monads
20:19:39 <ais523> the basic idea is, if I have a lambda calculus expression, and apply it to one or more arguments currying-style, then it will apply some of those arguments to others and this effectively describes its observable behaviour
20:20:22 <korvo> PCWWWWW: Monads show up a lot. They weren't one of the things category theorists wanted to study.
20:20:47 <ais523> and I'm trying to capture the idea of things that can "lift/box" this sort of description of the observable behaviour so that the definition can be applied to "lambda calculus with extras" virtual machines
20:20:49 -!- Thelie has quit (Remote host closed the connection).
20:21:11 <korvo> Adjunctions always give monads. So if you have two related categories, like rings and semirings, then you get a monad. The list monad, state monad, continuation monad, and maybe monad all have underlying adjunctions.
20:21:11 <ais523> but I'm still confused about precisely what it is that I'm trying to do
20:21:52 <ais523> PCWWWWW: category theory mostly doesn't contain things for the sake of it – the concepts of category theory came about because people noticed frequently occurring patterns and wanted a way to mathematically describe them
20:22:01 <korvo> 2-categories give monads as a special case. So if you want to study higher category theory, which arose for other reasons (∞-categories!) then monads naturally appear.
20:22:17 <ais523> it's very common for things to happen to form a monad, so having a way to describe/name the pattern that they follow is useful
20:22:35 <korvo> Yep. The original goal of category theory was to define "natural", particularly in "natural transformation". It wasn't until later that categories became useful on their own.
20:22:51 <PCWWWWW> yes. but like why endofunctors. why monoids. why not with semi groups
20:22:54 <ais523> if I remember correctly, category theory was originally invented because someone had discovered that natural transformations were really common and had useful properties, and wanted a mathematically rigorous way to define them
20:23:45 <ais523> so the reason it's endofunctors is that one of the things that monads have in common is that they can be flattened, e.g. you can flatten a list of lists into a list
20:23:51 <korvo> Endofunctors generalize endofunctions, and endofunctions show up all throughout science. Like, we computer scientists study discrete dynamical systems (DDSs), and physicists study much fancier stuff.
20:23:58 <ais523> but the flattening only makes sense if the outer wrapper and inner wrapper are the same
20:25:43 <korvo> Why not semigroups? *Excellent question*. Like, there's an entire schism about this. You can think of categories as like the minimum viable structure required to talk structurally about structure. Today we call this "formally formal". The semigroup folks were accused of doing "centipede maths", like when a child tortures a bug by ripping off legs.
20:26:35 <ais523> most children don't do that
20:26:52 <korvo> Today I'd recommend just trying your best to not have a bias about it. Think of the first category theory you learn as basic, simple, easy. Nothing complicated. No weird conditions. Just a structure.
20:27:08 <ais523> group theory was discovered before category theory was
20:28:00 -!- PCWWWWW has quit (Quit: Client closed).
20:28:20 <b_jonas> I have to rip off legs from bugs to understand category theory?
20:28:25 <zzo38> I didn't know that was the original goal of category theory
20:28:38 <ais523> korvo: I just realised that you can think of the relationship between group theory and category theory as being similar to the relationship between untyped and typed languages, except that somehow the addition of multiple objects makes it more powerful even though the addition of multiple types makes it less powerful
20:29:23 <korvo> Oh, I was talking *very specifically* about semigroups, sorry. Should I have understood the question more generally? https://en.wikipedia.org/wiki/Centipede_mathematics cites two category theorists and nLab.
20:29:42 <ais523> I guess the difference is that untyped lambda calculus doesn't really care if the operations you're performing don't make sense, most abstraction levels above it work by treating a lot of things as UB and avoiding them rather than working out what they would mean
20:30:22 <korvo> ais523: Yeah. Have you heard of groupoids yet? Every category contains a "core" groupoid, and some type theories work with groupoids first and categories second.
20:31:16 <ais523> korvo: yes as of maybe about 1 or 2 seconds before reading your comment
20:31:26 <ais523> I had heard of magmas earlier, but never looked up the definition (they're the same thing)
20:31:45 <korvo> And then the paradox you mention is resolved by the sheafiness/contravariance of the assignment from a type theory to its category of models. The initial model is "less powerful" in the sense that it can only do what the type theory requires it to do; all of the non-initial models are "more powerful" because they can contain types and operations not specified by the theory.
20:31:54 <zzo38> About programs that act as a HTTP server and you interact with them on a browser through a local tcp connection, I do not think it is a good way to make an interface that's portable among systems, since you might not have a compatible web browser, and it will have other issues, including the security issues you mention. Surely there are simpler ways to do it, especially if the program is local only.
20:32:31 <zzo38> And, the misfeature of Firefox that you mention, at least on my computer I have a old enough version of Firefox that I could add a JavaScript code in an extension to prevent it from displaying non-ASCII characters in the URL.
20:32:31 <ais523> korvo: oh, I hadn't started thinking about it as a paradox, just as an interesting observation
20:32:53 <ais523> I would like a way to get Firefox to escape non-ASCII characters in URLs to make Esolang easier to administer
20:33:16 <ais523> I have ways to see the homoglyphs but it's a pain, and one particular Esolang user seems to be fond of them
20:33:17 <zzo38> Using a web-browser at all is a messy way to handle many things.
20:33:26 <zzo38> ais523: What version of Firefox are you using?
20:33:29 <ais523> indeed, but it is easier that reading raw HTML
20:33:51 <korvo> Okay, I really do need lunch, and the farmer's market's almost closed too. Peace.
20:35:15 -!- Lord_of_Life has quit (Quit: Laa shay'a waqi'un moutlaq bale kouloun moumkine).
20:36:06 -!- Lord_of_Life has joined.
20:36:49 <zzo38> I used the code: window.losslessDecodeURI=function(aURI) { return aURI.spec; }; It is probably not compatible with 131.0 which I think cannot use XPCOM-based extensions, but you might try.
20:37:53 <ais523> I remember when Firefox's major version number was a single low digit
20:38:06 <ais523> I think they increased the rate of increasing the major version number at some point, and am not sure why
20:42:14 <ais523> clearly we need transfinite ordinal version numbers so we can keep accelerating the version number increases indefinitely, including beyond the normal limits
20:44:18 <int-e> it has become a totally meaningless number to me
20:44:39 <int-e> and I think it *is* meaningless; it's one major version per month
20:45:05 <int-e> so just progression of time, no real relation to features or other developments
20:45:21 <zzo38> I would rather use a different web browser since most of them aren't very good, and even Firefox isn't that good I tried to write extensions to improve it but some things still don't work as well as it should do. Furthermore, many things shouldn't need a web browser.
20:49:59 <int-e> I wonder how much hope to put into Ladybird
20:50:57 <int-e> But for the time being, Firefox still feels like the best compromise between evil and usability.
20:52:48 <zzo38> (Another thing I did is I had to modify the binary executable file by a hex editor in order to prevent HSTS from working.)
20:56:55 <zzo38> I would want one that doesn't try to believe they know better than what the user explicitly specifies. It is OK to avoid the use of CSS, and JavaScripts; the ability to write extensions in C would be a good idea, though. Relative URL entry also would be a good idea (another thing I had managed to implement in Firefox by adding a JavaScript code; I dislike the way it normally handles entered URLs)
20:57:17 <esolangs> [[Delta]] M https://esolangs.org/w/index.php?diff=143244&oldid=98599 * PythonshellDebugwindow * (+52) Stub, categories
20:59:35 <ais523> I dislike the way that browser default CSS is often bad enough that websites have to provide their own
21:00:15 <ais523> although the "reader mode" which applies an entirely different set of CSS as an override is sometimes useful, it's also bad at handling certain constructs like code blocks
21:00:33 <zzo38> I think the browser default CSS is better than what nearly all websites provide. The only thing that I think is missing is: img { max-width: 100%; }
21:01:00 <zzo38> But, regardless of my opinion, the user should apply their own preference of CSS.
21:03:56 <ais523> I tried to write some minimal default CSS for my blog
21:04:24 <ais523> that just fixed some of the worse issues with typical browser default CSS, also that applied colors to syntax-highlighted code blocks
21:04:44 <zzo38> At least the version of Firefox that I have, allows to disable CSS, and I often use that.
21:13:06 <zzo38> However, a problem with that is that pictures that are merely for decoration cannot be excluded by this, and sometimes are made too big (especially SVG pictures).
21:15:14 <esolangs> [[)]] https://esolangs.org/w/index.php?diff=143245&oldid=85542 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+22)
21:15:35 <esolangs> [[]] https://esolangs.org/w/index.php?diff=143246&oldid=123773 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+29)
22:10:33 -!- X-Scale has joined.
22:43:43 -!- molson_ has quit (Ping timeout: 245 seconds).
22:44:27 <esolangs> [[Pile]] https://esolangs.org/w/index.php?diff=143247&oldid=115692 * Marc-dantas * (-5654) Blanked the page
22:58:18 -!- __monty__ has quit (Quit: leaving).
23:16:49 -!- X-Scale has quit (Ping timeout: 256 seconds).