00:00:35  * keith_millerquit (Quit: My MacBook has gone to sleep. ZZZzzz…)
00:03:16  * keith_millerjoined
00:15:06  * rmarkins_joined
00:17:40  * rmarkinsquit (Ping timeout: 246 seconds)
00:19:30  * rmarkins_quit (Ping timeout: 250 seconds)
00:52:37  * keith_millerquit (Quit: My MacBook has gone to sleep. ZZZzzz…)
00:57:41  * gibson042quit (Quit: Leaving.)
01:00:32  * gibson042joined
01:03:15  * gibson042quit (Client Quit)
01:03:51  * aki_joined
01:04:34  * akirosequit (Ping timeout: 250 seconds)
01:04:35  * aki_changed nick to akirose
01:06:27  * rmarkinsjoined
01:10:56  * rmarkinsquit (Ping timeout: 240 seconds)
01:59:45  * cloudshuquit (Quit: Connection closed for inactivity)
02:32:17  * jwaldenquit (Quit: back in a bit)
02:43:47  * keith_millerjoined
02:48:06  * keith_mi_joined
02:50:54  * keith_millerquit (Ping timeout: 272 seconds)
03:07:15  * rmarkinsjoined
03:10:07  * akirosequit (Ping timeout: 240 seconds)
03:10:33  * akirosejoined
03:11:26  * obensourcequit (Ping timeout: 240 seconds)
03:11:32  * rmarkinsquit (Ping timeout: 250 seconds)
03:24:35  * obensourcejoined
03:54:38  * keith_mi_quit (Quit: My MacBook has gone to sleep. ZZZzzz…)
04:35:56  * cybaiquit (Ping timeout: 240 seconds)
05:16:35  * aki_joined
05:17:07  * akirosequit (Ping timeout: 240 seconds)
05:17:07  * aki_changed nick to akirose
05:43:44  * cybaijoined
06:00:42  * Sirisian_joined
06:03:54  * jmdyckquit (Remote host closed the connection)
06:03:56  * Sirisianquit (Ping timeout: 240 seconds)
06:25:48  * keith_millerjoined
06:37:15  * akirosequit (Quit: 👋🏻)
06:38:26  * keith_millerquit (Quit: My MacBook has gone to sleep. ZZZzzz…)
06:38:30  * akirosejoined
07:08:59  * rmarkinsjoined
07:13:07  * rmarkinsquit (Ping timeout: 246 seconds)
07:48:50  * Sirisian__joined
07:51:56  * Sirisian_quit (Ping timeout: 240 seconds)
08:38:42  * cybaiquit (Ping timeout: 268 seconds)
08:44:38  * aki_joined
08:45:31  * akirosequit (Ping timeout: 246 seconds)
08:45:31  * aki_changed nick to akirose
09:09:47  * rmarkinsjoined
09:14:05  * rmarkinsquit (Ping timeout: 244 seconds)
09:50:26  * Jessidhiaquit (Ping timeout: 240 seconds)
10:09:57  * AtumTjoined
10:50:54  * aki_joined
10:51:44  * akirosequit (Ping timeout: 250 seconds)
10:51:44  * aki_changed nick to akirose
11:03:26  * AtumT_joined
11:05:28  * obensourcequit (Ping timeout: 245 seconds)
11:05:53  * AtumTquit (Ping timeout: 245 seconds)
11:06:06  * obensourcejoined
11:06:43  * globbotquit (Ping timeout: 244 seconds)
11:08:02  * globbotjoined
11:10:40  * rmarkinsjoined
11:14:58  * rmarkinsquit (Ping timeout: 246 seconds)
12:57:36  * aki_joined
12:58:45  * akirosequit (Ping timeout: 250 seconds)
12:58:46  * aki_changed nick to akirose
13:31:31  * jmdyckjoined
13:59:05  * cybaijoined
14:24:15  <bradleymeck>ystartsev: mmm how do I run notes_explorer? its been soo long since I've done prolog that I've forgotten, it seems I need to use load_note -> inspect_discussion ?
14:24:37  <ystartsev>yes
14:24:41  <ystartsev>do you have swipl installed?
14:25:07  <bradleymeck>yup
14:25:34  <ystartsev>so the basic command is swipl notes_explorer/notes_explorer.pl
14:25:42  <ystartsev>if you are in the tc39 notes repo
14:25:49  <ystartsev>this will get the environment set up
14:26:06  <ystartsev>rlwrap is to make swipl less annoying
14:26:49  <ystartsev>then you can load a note, for example: load_note("./es9/2018-11/nov-28").
14:26:53  <ystartsev>this is probably what is wrong
14:26:58  <ystartsev>i got the date wrong in the slides!
14:27:22  <ystartsev>slides are now fixed bradleymeck ^
14:27:51  <ystartsev>once that works, you can try loading a note using the following: print_info.
14:27:59  <ystartsev>it will just print all info thats been loaded so far
14:28:17  <ystartsev>from there you can grab a discussion name or a value and inspect its relationship to other things
14:28:28  <ystartsev>(i will make the user experience better soon)
14:28:37  <ystartsev>(i will also stop abusing format soon 😰
14:29:31  <ystartsev>i wrote the entire thing in one sitting so it isn't perfect -- let me know any issues you run into
14:29:35  <ystartsev>i also haven't written all of the viewers
14:34:14  <devsnek>what is notes_explorer
14:34:51  <ystartsev>its an experimental .... thing? ... i think thing is the best word .. that combs the notes and creates relationships between discussions
14:35:36  <ystartsev>its here : https://github.com/codehag/tc39-notes
14:35:44  <ystartsev>its basically a prolog program that looks for tags that I add to the notes
14:37:23  <bradleymeck>ystartsev: what are the args to print_info, [In/Ins] doesn't seem to take a .md filepath string?
14:37:31  <ystartsev>it doesnt take args
14:37:34  <ystartsev>it just prints everything it has
14:37:47  <ystartsev>oh wait a sec, maybe i got something wrong
14:38:13  <ystartsev>ah sorry the cmd is write_to_text.
14:38:17  <ystartsev>not print_info
14:38:21  <ystartsev>print info is more general
14:38:25  <ystartsev>i got the slides wrong, sorry
14:38:46  <ystartsev>i updated them again
14:39:01  <ystartsev>you can also use write_to_dot. or write_to_json.
14:39:21  * arkainjoined
14:40:56  <ystartsev>i will write up the readme properly in a few days when i have a moment
14:41:19  <ystartsev>but if you know prolog, and you load the note -- you can start playing with that world as you like
14:41:22  <devsnek>prolog though
14:42:11  <ystartsev>example: findall(X, lookup("Expression", X, tension("Expression, X)), Tensions), print(Tensions).
14:42:15  <ystartsev>i really like prolog
14:42:20  <ystartsev>its easy to prototype in
14:42:45  <ystartsev>you just throw things at it, and its like "oook sure". as long as you dont make any mistakes that is :|
14:42:50  <ystartsev>the errors are something else
14:43:11  <ystartsev>i messed up typing, should be findall(X, lookup("Expression", X, tension("Expression", X)), Tensions), print(Tensions).
14:43:22  <ystartsev>im treating prolog as a relational database and parser
14:43:38  <ystartsev>its just for the prototype
14:45:44  <devsnek>html spec builder is also prolog
14:45:47  <devsnek>maybe i should learn it
14:45:50  <ystartsev>its fun!
14:46:08  <ystartsev>really, the main issue with it is that it gives the most misleading errors
14:46:25  <ystartsev>for example, i wrote an assembler in it, and i kept running out of memory
14:46:37  <ystartsev>i thought it was because i was compiling an operating system in it and i was just really inefficient
14:46:38  <ystartsev>nope.
14:46:41  <ystartsev>i had a typo
14:46:50  <devsnek>i've been trying to write an assembler
14:46:57  <devsnek>(nothing that could compile an os)
14:47:17  <ystartsev>so i wrote one for a fake machine: https://github.com/codehag/asm_in_prolog
14:47:28  <ystartsev>its a 16 bit machine, from the course nand2tetris
14:47:37  <ystartsev>if you want to build a computer from scratch, i can recommend that course
14:47:38  <devsnek>i think i'm getting the ops wrong though cuz trying to run the machine code always segfaults
14:48:46  <ystartsev>if you are writing for a specific architecture it might be harder -- the 16 bit machine i was working with is quite limited and it made it easier to find my way around
14:49:00  <ystartsev>the second half of the course is building the OS that you can compile using that assembler
14:49:15  <ystartsev>you also write a compiler for a java like language, and then a game in the java like language
14:49:19  <ystartsev>the teachers are really good
14:49:31  <devsnek>i was just trying to emit some x86
14:50:32  <ystartsev>hm, thats much more complicated than what i was doing!
14:50:48  <devsnek>what machine were you working with
14:51:01  <ystartsev>its a virtual machine that you build. they call it the HACK computer
14:51:32  <ystartsev>they take you through hardware design and you build it yourself from first principles
14:51:55  <devsnek>sounds fun
14:52:12  <ystartsev>this is the course: https://www.nand2tetris.org/
14:52:25  <bradleymeck>ystartsev: sent PR with README based upon what ya taught me here
14:52:35  <ystartsev>thank you bradleymeck !
14:53:21  <devsnek>i'll take a look at this
14:53:50  <ystartsev>devsnek: they have a version of it on coursera as well
14:54:43  <ystartsev>but everything is available on their website, so whatever your learning style is is the one you should go with
15:02:48  * aki_joined
15:03:56  * akirosequit (Ping timeout: 250 seconds)
15:03:57  * aki_changed nick to akirose
15:11:42  * AtumTjoined
15:12:21  * rmarkinsjoined
15:12:39  * AtumT_quit (Ping timeout: 244 seconds)
15:14:07  * AtumT_joined
15:16:28  * rmarkinsquit (Ping timeout: 246 seconds)
15:17:07  * AtumTquit (Ping timeout: 240 seconds)
15:26:20  * Jessidhiajoined
15:36:40  * rmarkinsjoined
15:39:34  * rmarkinsquit (Remote host closed the connection)
15:40:10  * rmarkinsjoined
15:40:26  * Jessidhiaquit (Quit: Textual IRC Client: www.textualapp.com)
15:40:48  * Jessidhiajoined
16:14:28  * cloudshujoined
17:06:56  * keith_millerjoined
17:08:26  * aki_joined
17:08:42  <rkirsling>ystartsev: that always sounded like a neat course indeed
17:09:36  * akirosequit (Ping timeout: 250 seconds)
17:09:36  * aki_changed nick to akirose
17:11:27  * jwaldenjoined
17:20:43  * obensourcequit (Ping timeout: 246 seconds)
17:31:12  * gibson042joined
17:34:48  * obensourcejoined
17:35:36  * gibson042quit (Ping timeout: 250 seconds)
17:51:02  * gibson042joined
18:21:25  * keith_millerquit (Quit: My MacBook has gone to sleep. ZZZzzz…)
18:25:28  * AtumT_quit (Ping timeout: 245 seconds)
18:27:22  * AtumTjoined
18:33:36  <bradleymeck>littledan: i was thinking of floating a patch with the web compat hack for the override PR to see a less skewed usage counter, does that make sense?
18:34:20  <littledan>what do you mean, floating?
18:34:21  <bradleymeck>i see you just closed it, but the usage counter was pretty wildly out of the norm and largely appeared to be due to 1 library so I'm not convinced it is as dangerous as it may seem at first glance
18:34:40  <bradleymeck>littledan: node can float a v8 patch and flag to see how much breaks
18:34:42  <littledan>yeah, that might be the case, but I'm not sure
18:34:51  <bradleymeck>right now lodash breakage makes usage counters useless
18:35:11  <littledan>I don't understand what you mean by "useless"; they reflect lodash
18:35:18  <bradleymeck>doesn't really say much about anything outside of that and it is unclear how much breaks due to lodash's change
18:35:23  <littledan>there was no V8 patch to change the actual semantics, just to count how often it occurred
18:35:51  <littledan>to make more progress here, i'd recommend implementing these other semantics, and one or more of these additional fixes, and surfing around to see what breaks
18:36:02  <bradleymeck>littledan: the usage counters are biased around a bug in older lodash that shows massive breakage if you don't do a compat hack around lodash
18:36:35  <littledan>I understand that, but I don't know for sure that there aren't other widely used libraries that hit similar issues, but for which the tweak doesn't fix it
18:36:41  <bradleymeck>littledan: yes, floating the web compat fixes for the older lodash should make the actual impact of the change clearer
18:36:43  <littledan>at this point, i feel like we should've done a bit more "surfing around and seeing what breaks" before landing the usage counter
18:37:05  <littledan>so, is someone interested in doing this V8 programming, and then locally running a hacked-up version of Chrome and testing various things?
18:37:09  <littledan>that's what I'd recommend next
18:37:16  <bradleymeck>that line of code is not clear just reading the src that it relied on that behavior
18:37:21  <littledan>I don't really understand what floating on Node would accomplish
18:37:22  <bradleymeck>idk if surfing around would have helped
18:37:31  <littledan>well, maybe not
18:37:44  <littledan>but if we put an assertion, it would've shown that it was hit
18:37:54  <littledan>actually seeing that this one-off fix fixes it is harder
18:38:07  <bradleymeck>yup
18:38:23  * AtumTquit (Ping timeout: 245 seconds)
18:38:36  <littledan>what caitp is working on in Igalia now is investigating what it would take to make stuff like the frozen realm shim run faster
18:38:41  <bradleymeck>running local version of node would be my main way of doing this as I don't have experience building chrome
18:38:56  <bradleymeck>but node hits the same path in lodash
18:40:03  <bradleymeck>but to put things in perspective
18:40:13  <bradleymeck>frozen realms etc. are not super usable as it stands
18:40:25  <bradleymeck>the node PR implementing frozen intrinsics points this out
18:40:30  <caitp>bradleymeck: can you elaborate?
18:40:59  <bradleymeck>caitp: lots of things "dont work" if your intrinsics get frozen due to lots of errors or noops occuring around these non-writable properties
18:41:30  <bradleymeck>mark's work relies on completely changing a lot of properties from data to accessor props to try and work around this
18:41:42  <bradleymeck>but that isn't how JS specified intrinsic properties
18:42:38  <bradleymeck>see https://github.com/nodejs/node/pull/25685 , where it shows up from a different party investigating the approach of freezing intrinsics
18:43:02  <caitp>my understanding is that the proposal is designed to protect against this sort of thing, especially from untrusted code
18:43:21  <bradleymeck>"this sort of thing"?
18:43:22  <caitp>would you say there needs to be a layer where it's always allowed?
18:43:30  <bradleymeck>"it"?
18:43:40  <caitp>this sort of thing -> changing properties on intrinsics
18:43:45  <caitp>adding new ones, etc
18:43:48  <bradleymeck>correct, that is not the problem
18:44:01  <bradleymeck>the problem is as laid out in that node PR and others, that subclassing can break
18:44:23  <bradleymeck>and various other things if you have non-writable (such as frozen) properties in your proto chain
18:44:38  <bradleymeck>even worse, it doesn't always throw
18:44:44  <bradleymeck>it sometimes just noops
18:44:52  <bradleymeck>depending on strict/sloppy
18:45:09  <caitp>ah I see
18:45:23  <bradleymeck>so, without fixing this, frozen realms are... not as usable
18:46:17  <caitp>well, subclassing builtins is a relatively recent thing right? not 20 years of legacy code doing that
18:46:31  <bradleymeck>caitp: not just builtins and not just using class syntax
18:46:38  <bradleymeck>any way of putting things in the prototype chain
18:46:54  <bradleymeck>so things like the old fn.prototype.toString = function () {} start throwing
18:47:00  <bradleymeck>or nooping...
18:47:03  <caitp>ok, that's fair
18:47:47  <bradleymeck>hence my pushing node for web compat hacks
18:50:13  <bradleymeck>to my knowledge the only breakage of importance seems to be lodash but signal/noise ratio is too high without the compat hack (which itself might be breaking) to know if other things are relying on this
18:50:44  <bradleymeck>even if we just fix it in strict mode, it seems like it would be pref to doing nothing, as frozen prototypes make entire codebases unusable for now
18:53:51  <littledan>bradleymeck: I mean, you can do this experiment in Node, but I wouldn't be convinced that it demonstrates web compatibility
18:54:03  <littledan>the only thing it could really demonstrate is likely incompatibility
18:54:07  <caitp>the compat hack will clearly affect a lot of code, but how much of it would actually become broken? it's hard to estimate
18:54:31  <littledan>well, if we're talking about Object.prototype.toString fallbacks, I'm pretty comfortable with adding more of those
18:54:34  <bradleymeck>littledan: showing if the web compat hack is incompatible is of value here
18:54:57  <bradleymeck>as it would at least let us figure out a way to get a better signal/noise ratio on usage counters
18:55:02  <littledan>I'd be pretty surprised if adding more of these fallbacks broke anything, but I wouldn't be surprised if it didn't fix enough
18:55:22  <littledan>but those are just guesses
18:55:56  <littledan>anyway this takes a nontrivial amount of C++ coding to implement; there's no patch out there that you can just float
18:56:17  <bradleymeck>littledan: the tostring workaround?
18:56:23  <littledan>yes
18:56:31  <littledan>basically we're talking about a partial revert of ES6 here
18:56:47  <bradleymeck>it is doable in pure JS even if you replace all the refs unless I'm missing something?
18:57:02  <littledan>sure? I'm not sure what you're trying to get at
18:57:33  <caitp>there could potentially be angularjs 1.x apps out there which define readonly properties on a $scope, and then try to overwrite them in child scopes --- IIRC doing this with non-readonly properties was a pretty common (accidental) pattern
18:57:55  <caitp>so if someone did that with a non-readonly property, it could break the app... but it is a big if
18:58:35  <bradleymeck>caitp: even with that going on the question remains of if strict mode which errors suddenly didn't error would things break
18:58:55  <bradleymeck>but we just have too much going on
18:59:44  <bradleymeck>need to reduce noise to get any sort of direction
18:59:46  <caitp>well I think the only way to really find out is to do an experiment where some % of browsers get the special behaviour and some don't
18:59:58  <caitp>or put it on a webcrawler or something
19:00:19  <bradleymeck>we did that with usage counters so that we wouldn't break things
19:00:29  <caitp>yes but as you say, signal/noise
19:00:36  <caitp>it doesn't indicate breakage
19:15:03  * aki_joined
19:15:07  * akirosequit (Ping timeout: 240 seconds)
19:15:18  * aki_changed nick to akirose
19:17:21  <TabAtkins>Hmm. If proxies effectively let you overload the = operator (and a few more), more general operator overloading shouldn't be any slower than that, right?
19:17:58  <TabAtkins>Or is = already kinda slow, so the fact that you have to check if you need to indirect thru a proxy or a setter not generally a perf hit, but doing the same for + would be?
19:22:47  * cybai_joined
19:22:47  * keith_millerjoined
19:25:28  * cybaiquit (Ping timeout: 245 seconds)
19:25:39  <bradleymeck>TabAtkins: they already let you control the Set operation for that, I'm not sure I understand the question
19:26:27  <TabAtkins>Yes, that's my point. We already have overloading of *some* operators, so I'm curious about if overloading the rest is problematic in new and exciting ways, or just the same ways we already know about?
19:26:36  <caitp>you can control `proxy = <something + something>`, but you can't control what `<something> + <something>` gives you
19:29:08  <TabAtkins>yes
19:30:33  <TabAtkins>...I'm not sure how my words could be read this way, but just in case: I'm not asking to expand Proxies to handle operator overloading. I'm asking about the perf implications of proxies, and how it compares to the perf implications of more general operator overloading.
19:30:54  <TabAtkins>Because one of the main objections to general overloading is that it slows down all math, etc.
19:42:11  * keith_millerquit (Quit: My MacBook has gone to sleep. ZZZzzz…)
19:48:52  <bradleymeck>proxies are noticeably slower last I checked, doubt that will ever change since you have to call into JS which I don't think can be optimized out
19:54:02  <bradleymeck>littledan: to confirm, https://jsbin.com/qajukupuca/edit?js,console is my understanding of the behavior change that was being talked about?
19:56:10  <caitp>bradleymeck: mslekova and some others have done a fair bit of work to keep some (maybe all at this point) proxy operations in JS, and I don't think there's any reason we couldn't add some support for the js-inlining pass. it should be possible to be substantially faster than it was originally
20:12:56  <caitp>that work is unlikely to happen before proxies see heavier use in perf-critical code though, or before there's a demand for that.
20:18:46  <littledan>bradleymeck: Yep, I agree that this hits the codepath that jridgewell traced in the issue
20:18:52  <littledan>I just don't know whether this is the only issue out there
20:19:33  <bradleymeck>littledan: it is probably not the only issue to be clear, but it has soo much noise that no other ones were found on cursory checks
20:22:22  <littledan>well, sure, but I don't understand how you want to eliminate the noise
20:22:41  <littledan>if you fix up that piece, it will still be after the UseCounter clicks
20:28:00  <bradleymeck>littledan: maybe we were using the usage counter for different purposes?
20:29:11  <bradleymeck>even if the usage is "high", if the behavior doesn't change it wouldn't be problematic? also in the past thrown -> non-thrown has been treated as non-problematic which affects strict mode change
20:48:14  <caitp>how confident do you think you'd have to be that it wouldn't break the web most of the time to convince maintainers to run a finch trial (or just ship the proposed change in nightly)?
20:48:26  <devsnek>how does a proxy override equality
20:51:59  <devsnek>oh it was the set operation
21:02:45  <bradleymeck>caitp: I'd have to go through a large test of using local chrome + puppeteer or something so that nothing seems crazy, 15% is enough that top 10k websites should have it show up plenty and that at least might be enough. I'd still be somewhat wary and need to put in more checks just to ensure that we skip the lodash hack when retesting. this feels a bit brutal though
21:04:18  <bradleymeck>strict mode counter is less concerning but still at that massive 1.5%
21:09:16  <devsnek>lodash is still all over the internet
21:09:17  <caitp>looking at the origin trials docs, we have done most of what's required for a field test
21:11:24  <caitp>ok maybe not most of, probably the 2 most passive things, but still
21:18:47  * gibson042quit (Quit: Leaving.)
21:19:52  <bradleymeck>devsnek: updated lodash is not affected and some historically old lodash are not affected
21:22:08  * aki_joined
21:23:06  * akirosequit (Ping timeout: 250 seconds)
21:23:06  * aki_changed nick to akirose
21:41:53  * regaddiquit (Quit: ZNC - http://znc.in)
21:52:23  * regaddijoined
22:03:18  * keith_millerjoined
22:08:51  <devsnek>bradleymeck: but there are still versions of it floating around right?
22:12:30  <bradleymeck>yup, but web compat hack makes it still function correctly even w/ change
22:15:36  <devsnek>web compat hack
22:17:23  <bradleymeck>a tried and true tradition!
22:17:34  <devsnek>what's the hack
22:18:48  <bradleymeck>modifying Object.prototype.toString to include typed arrays instead of having typed arrays delegate to the TypedArray.prototype[toStringTag] getter (the fact it was a getter was kind of wild to me)
22:19:20  <devsnek>I see
22:19:47  <devsnek>it's still kind of wild to me that failed sets would walk down the prototype
22:20:40  <bradleymeck>mmm?
22:20:53  <bradleymeck>if it fails, it stops
22:21:37  <devsnek>isn't the whole idea that the change would be to go from fail = no set to fail = try on the parent
22:23:03  <bradleymeck>nope
22:23:21  <devsnek>I'm confused then
22:23:26  <bradleymeck>non-writable in proto crawl would perform define on reciever
22:23:32  <bradleymeck>thats the change
22:23:38  <bradleymeck>currently in sloppy, it noops
22:23:43  <bradleymeck>currently in strict, it throws
22:24:05  <devsnek>so it goes straight to the receiver
22:24:26  <devsnek>not as weird but still weird
22:24:33  <bradleymeck>well it delegates up to see if a setter exists
22:25:43  <devsnek>so it does walk back down the prototype?
22:27:02  <bradleymeck>yup
22:27:18  <bradleymeck>but it stops walking when it encounters any given descriptor
22:27:22  <bradleymeck>same as today
22:27:58  <devsnek>so it goes until it finds the prop, and if it's non writable it goes back a steo
22:28:06  <devsnek>step*
22:29:19  <bradleymeck>idk if it goes back a step, it can take action without rolling anything back
22:29:49  <devsnek>back a prototype
22:30:26  <bradleymeck>nah
22:30:34  <bradleymeck>it just places it directly on the reciever
22:30:42  <bradleymeck>no need to crawl back to find the reciever
22:32:29  <devsnek>but when i said that before
22:32:40  <devsnek>you said "well it delegates up to see if a setter exists"
22:34:49  <bradleymeck>down/up isn't a good terminology here ;p
22:34:55  <bradleymeck>it only does it in 1 direction
22:35:21  <devsnek>walk prototype to find property
22:35:26  <devsnek>property isn't writable
22:35:32  <devsnek>do write on receiver instead
22:35:36  <bradleymeck>yes
22:35:54  <devsnek>what if receiver isn't writable
22:36:34  <devsnek>same behaviour as now?
22:36:52  <bradleymeck>yup
22:38:31  <devsnek>still feels kinda weird
22:38:41  <TabAtkins>bradleymeck: Right, proxies are slower. But we still put them in the language. One of the blockers brought up for operator overloading is that it'll be slower. Is it slower in a way that is different from proxies, or worse in some important way?
22:38:42  <devsnek>like why not just explicitly create whatever prop it is on your object
22:40:00  <bradleymeck>devsnek: because assignment is the expected UX
22:40:06  <devsnek>TabAtkins: depends on how operator overloading is done
22:40:18  <devsnek>bradleymeck: but the assignment failed
22:40:23  <devsnek>because the property wasn't writable
22:40:33  <bradleymeck>TabAtkins: Proxies allow you to create your own forms of the meta-object protocol / create your own exotics, overloading is something else
22:40:54  <TabAtkins>Right, but it's also kinda overloading the = operator, right? Is that significantly different than overloading the + operator?
22:40:58  <devsnek>bigint adds a protocol for mathematical operators
22:41:08  <TabAtkins>(ignoring the issues of right-vs-left operators, etc)
22:41:09  * gibson042joined
22:41:12  <bradleymeck>devsnek: not really, getter/setters can still have success even if they are not writable, this isn't really related to some sort of mental model of what "writable" means
22:41:51  <bradleymeck>TabAtkins: it doesn't overload = really, not sure I understand, = does call the set() trap though
22:41:56  <devsnek>TabAtkins: the usual design of operator overloading would make every operator have to check the operand for an overload
22:42:23  <TabAtkins>"call the set() trap" sounds a *whole lot* like "check if the LHS has overloaded its = operator" to me
22:42:39  <devsnek>it is
22:42:55  <devsnek>setting is slower than it could be because exotic objects exist
22:43:35  <bradleymeck>TabAtkins: it doesn't really to my knowledge, `x = 1` doesn't ever fire that trap and `x.y = 1` doesn't mean it fires from `x` and instead could fire from `x.__proto__`
22:43:38  <TabAtkins>Okay, right, so = is *already* slow for reasons, and proxies don't make it appreciably worse? But + is fast right now, and operator overloading would make it significantly slower (equivalent to = and proxies)?
22:44:01  <bradleymeck>TabAtkins: I just see them as fundamentally different, so I'm confused mostly
22:44:09  <devsnek>in an interpreter = is slow
22:44:33  <devsnek>optimization can help of course
22:44:43  <TabAtkins>bradleymeck: Details, details, the point is you're hijacking some syntax forms to magically invoke a special function instead.
22:45:06  <bradleymeck>TabAtkins: those details are the difference, so i don't understand that comment
22:45:10  <devsnek>bradleymeck: after bigint lands, mathematical operators have their own protocol
22:45:52  <devsnek>so addition goes from an O(3) game to an O(4) game
22:46:01  <bradleymeck>kind of, but not in the sense of it being exposed / having scaling issues
22:46:19  <TabAtkins>`x.y = 1` becoming `x.proxySet('y', 1)` (essentially) feels similar to `x + y` becoming `x.operatorAdd(y)`; the difference I'm seeing is that = is already having to do (relatively slow) work because of various exotic objects, while + gets to fast-track more often, so adding an overloading check is a minor penalty for =, but a big penalty for +.
22:46:22  <bradleymeck>we add things to various algorithms all the time
22:46:23  * rmarkinsquit (Remote host closed the connection)
22:46:56  <devsnek>and it makes interpreters really slow
22:47:01  * rmarkinsjoined
22:47:18  <bradleymeck>TabAtkins: I would disagree on that point as x.operatorAdd(y) might not match y.operatorAdd(x), one might state that operatorAdd(x, y) is the less confusing approach
22:47:31  <bradleymeck>but even then, you probably don't want this on the proxy
22:47:38  <TabAtkins>bradleymeck: Sure, whatevs on exactly how you figure out what to dispatch.
22:48:30  <bradleymeck>the dispatch is rather important here, does it live on an operand that the operation is being performed on or independently changes if you need to do the lookup at the site or it can be static
22:48:36  <TabAtkins>bradleymeck: I'm not saying add this functionality to proxies. I'm using proxies as an example of seemingly-similar functionality that was accepted by the committee, to question one of the objections to overloading.
22:48:44  <bradleymeck>for member expressions the assignment always does the lookup
22:48:46  <devsnek>right now overloads live on the operator
22:49:47  <bradleymeck>TabAtkins: i have other objections than speed, but tradeoffs of speed are generally going to be case by case, and introducing more means those tradeoffs become harder to justify over time
22:50:13  <bradleymeck>the usability aspect of overloading is interesting, but makes many things much harder to reason about
22:51:07  * rmarkinsquit (Ping timeout: 240 seconds)
22:51:45  <devsnek>it would probably only work as an uninherited internal field
22:55:56  * rmarkinsjoined
22:56:44  * rmarkinsquit (Read error: Connection reset by peer)
22:57:15  * rmarkinsjoined
23:01:47  * rmarkinsquit (Ping timeout: 244 seconds)
23:02:10  * rmarkinsjoined
23:18:41  * gibson042quit (Quit: Leaving.)
23:25:46  * keith_millerquit (Read error: Connection reset by peer)
23:26:32  * keith_millerjoined
23:29:07  * aki_joined
23:30:03  * akirosequit (Ping timeout: 245 seconds)
23:30:05  * aki_changed nick to akirose
23:46:11  * keith_millerquit (Quit: My MacBook has gone to sleep. ZZZzzz…)
23:50:54  * gibson042joined
23:58:14  * keith_millerjoined