00:29:37  * laughinghanjoined
00:33:01  <jmdyck>cj's talk = https://www.youtube.com/watch?v=MO8hZlgK5zc ?
00:35:03  * cybaijoined
00:39:10  * cybaiquit (Ping timeout: 246 seconds)
00:39:11  <rkirsling>jmdyck: yep!
00:39:17  <jmdyck>tx
00:39:26  * rektide_changed nick to rektide
00:56:14  * AtumTquit (Quit: AtumT)
01:22:35  * keith_mi_joined
01:46:08  <devsnek>someone who works on test262.report, do you know on average how many tests are marked skip/flake by engines?
02:01:06  * keith_mi_quit (Quit: My MacBook has gone to sleep. ZZZzzz…)
02:29:08  * keith_mi_joined
02:55:11  * keith_mi_quit (Remote host closed the connection)
02:55:41  * keith_mi_joined
02:57:34  * laughinghanquit (Quit: My MacBook has gone to sleep. ZZZzzz…)
03:18:45  * keith_mi_quit (Quit: My MacBook has gone to sleep. ZZZzzz…)
03:23:52  * laughinghanjoined
03:32:56  * cybaijoined
04:05:17  * laughinghanquit (Quit: My MacBook has gone to sleep. ZZZzzz…)
04:08:43  * laughinghanjoined
04:26:48  * jmdyckquit (Remote host closed the connection)
04:36:19  * laughinghanquit (Quit: My MacBook has gone to sleep. ZZZzzz…)
05:29:33  * itamarokjoined
05:44:06  * itamarokquit (Remote host closed the connection)
05:48:05  * itamarokjoined
05:50:58  * itamarokquit (Remote host closed the connection)
05:54:20  * itamarokjoined
06:12:13  * cybaiquit (Remote host closed the connection)
06:13:21  * cybaijoined
06:17:48  * cybaiquit (Ping timeout: 258 seconds)
08:15:45  * itamarokquit (Remote host closed the connection)
10:32:08  * jmdyckjoined
10:36:47  * Nimelrianjoined
10:42:05  * itamarokjoined
10:43:03  * itamarokquit (Remote host closed the connection)
10:43:21  * itamarokjoined
12:56:13  * cloudshuquit (Quit: Connection closed for inactivity)
12:57:01  * cloudshujoined
13:40:50  * ErrorIsNullErrorjoined
13:54:05  <ErrorIsNullError>devsnek, I still don't understand. Prehaps "intent" is the wrong word/ I'm trying to figure out what it enables engines to do? AFAICT, all the predictability benefits fall out of the similar language in HostResolveImportedModule. I suppose without it a transient network or file-system failure during the first call to HostImportModuleDynamically(referencingScriptOrModule,specifier) or a cache expiration between calls might l
14:03:45  * itamarokquit (Remote host closed the connection)
14:27:00  <devsnek>ErrorIsNullError: it's about preventing the thing you can do in commonjs where you modify the module cache
14:46:15  <ErrorIsNullError>devsnek, As in require.cache in Node.js?
14:46:32  <devsnek>yes
14:46:39  <ErrorIsNullError>Thanks for explaining.
14:46:40  <devsnek>I guess webpack has that too
14:47:53  <ErrorIsNullError>Yeah. IIRC, webpack creates a stub require function, and requiring a module looks up into a cache and evals the rewritten module body text on a cache miss.
14:50:33  <ErrorIsNullError>I've been reading the related parts of html.spec.whatwg and I think I've got a better handle on how FinishDynamicImport expects the module graph to be fleshed out (per the Assert of the evaluated bit).
14:50:56  <ErrorIsNullError>I was missing that bit of context though, so thanks for that.
14:53:27  <ErrorIsNullError>I'll prep an editorial PR that adds a note relating to that, and invite Daniel+Domenic to review. May lead to useful discussion, and/or help someone else who has the same confusion.
14:57:40  * AtumTjoined
15:29:08  * cybaijoined
15:33:20  * cybaiquit (Ping timeout: 248 seconds)
15:40:13  * Nimelrianquit (Ping timeout: 258 seconds)
15:55:09  * tobie_joined
15:59:58  * annevk_joined
16:00:24  * cybaijoined
16:03:12  * tobiequit (*.net *.split)
16:03:12  * annevkquit (*.net *.split)
16:03:12  * Draggorquit (*.net *.split)
16:03:13  * tobie_changed nick to tobie
16:03:13  * annevk_changed nick to annevk
16:04:38  * cybaiquit (Ping timeout: 245 seconds)
16:11:01  * Draggorjoined
16:16:48  * cybaijoined
16:42:38  * laughinghanjoined
16:56:13  * cybaiquit (Remote host closed the connection)
17:13:32  * cybaijoined
17:19:59  * cybaiquit (Remote host closed the connection)
17:33:57  * keith_mi_joined
17:34:04  * keith_mi_quit (Remote host closed the connection)
17:34:55  * keith_mi_joined
17:55:40  * keith_mi_quit (Remote host closed the connection)
17:55:57  * keith_mi_joined
17:55:57  * keith_mi_quit (Read error: Connection reset by peer)
17:56:50  * keith_mi_joined
18:02:16  * cybaijoined
18:02:30  * cybaiquit (Remote host closed the connection)
18:10:29  * Nimelrianjoined
18:11:23  * cybaijoined
18:15:48  * cybaiquit (Ping timeout: 258 seconds)
18:23:50  * itamarokjoined
18:26:37  <keith_mi_>cloudshu: Another possibly controversial proposal now that we have WeakRef collection semantics: WeakSet/Map iteration
18:26:41  <keith_mi_>thoughts?
18:27:00  <Bakkot>:(
18:27:10  <keith_mi_>why :(
18:27:30  <cloudshu>keith_mi_: you want to iterate over existing WeakMaps?
18:27:34  <Bakkot>WeakRefs are a thing which very few people should need to know about or use, which limits the extent to which GC is exposed to random people writing JS; this is not the case for WeakMaps
18:27:36  <keith_mi_>seems like a useful feature and is an example on the WeakRef doc
18:27:42  <cloudshu>which are explicitly ephemeron things that aren't meant to be iterable?
18:28:01  <cloudshu>yeah i'm with Bakkot on this one
18:28:02  <keith_mi_>Yeah basically
18:28:59  <devsnek>are weak collection iterators async iterators
18:29:04  <keith_mi_>word, I can 100% guarantee you that there's going to be a library that makes an iterable WeakMap and it's going to be popular
18:29:21  <devsnek>i'd rather it was a library
18:29:25  <keith_mi_>there's not iterators right now
18:29:31  <devsnek>no i mean
18:29:39  <devsnek>the conceptual weak collection iterators
18:29:51  <keith_mi_>why would they need to be?
18:30:09  <devsnek>couldn't you observe collection by doing like `while (true) { [...thing.values()] }`
18:30:21  <keith_mi_>no it would have the same semantics as WeakRef
18:30:25  <devsnek>isn't that why finalization groups call back in a next tick
18:30:40  <keith_mi_>once you have iterated the value it's keptAlive until the next tick
18:30:45  <devsnek>oh ok
18:30:47  <devsnek>makes sense
18:31:03  <devsnek>still with bakkot though
18:31:19  <devsnek>the thing i really want is a WeakValueMap
18:31:25  <keith_mi_>I don't get the advantage of it being a library
18:31:33  <cloudshu>keith_mi_: oh for sure, there will be an iterable weakmap on top of weakrefs
18:31:40  <cloudshu>you can do weakvaluemaps on top of weakrefs also
18:31:54  <devsnek>yeah but it would be nice in std
18:31:56  <keith_mi_>devsnek: that's just weakMap where the values are WeakRefs
18:32:03  <devsnek>yes
18:33:17  <cloudshu>keith_mi_: i think the advantage is that the existing invariant for WeakMaps stays as is, and that the "there be heavy impl-dependent timing here" is only limited to grepping for weakrefs
18:33:38  <keith_mi_>cloudshu: I think that would still be true
18:33:48  <cloudshu>keith_mi_: what's the motivation for adding iteration beyond "it'll be possible anyway with a container on top of weakrefs"?
18:34:07  <keith_mi_>I just think it's going to be in 100% of wild uses of WeakMap
18:34:13  <keith_mi_>so we might as well add it
18:34:23  <keith_mi_>so engines can optimize
18:34:27  <devsnek>i think people also take advantage of weak collections being uninspectable
18:34:34  <devsnek>whatever the term is
18:34:42  <Bakkot>wat
18:34:43  <Bakkot>WeakMaps are already widely used without iteration
18:35:04  <devsnek>there is one case i can think of where i would use this
18:35:13  <cloudshu>keith_mi_: wait, what
18:35:13  <devsnek>but that's one case in like a billion times i've used weakmap
18:35:43  <cloudshu>what are you envisioning people doing? creating a shadow map of weakrefs holding on to weakmap keys, just so they can iterate?
18:35:47  <keith_mi_>afaik all the web inspectors have added this themselves
18:36:35  <Bakkot>they've also all exposed promise resolution status, beause it's nice when debugging, but that doesn't mean it makes sense to add that to the language
18:37:06  <keith_mi_>My point is now that it's possible to add it's going to be done, ubiquitously.
18:37:16  <devsnek>wouldn't this also break the implementation style where weakmaps are just a wrapper that assign hidden props on the key objects
18:37:32  <cloudshu>well, presumably not until you actually do the iteration
18:37:39  <keith_mi_>how would it?
18:37:46  <keith_mi_>the weakmap isn't exposed
18:38:57  <cloudshu>keith_mi_: put another way, what are we gaining by standardizing it becaues it's possible?
18:39:06  <cloudshu>i can't really say i agree or disagree with ubiquity
18:39:22  <Bakkot>I expect it will be done less, much less, if it's in a library rather than in the language.
18:39:30  <devsnek>anyone have any theories about why lint would fail on ci but work locally
18:39:56  <keith_mi_>I mean there's no rush on this since we can easily find out later
18:39:59  <Bakkot>(and also being in a library will mean it's opt-in; adding a library will not grant other people the ability to iterate my non-library weakmaps)
18:40:33  <ljharb>making an iterable weakmap is fine, but allowing weakmaps to be iterable would be terrible
18:40:56  <cloudshu>i'm still confused how the library will do tihs for existing weakmaps besides keeping a shadow map
18:42:20  <keith_mi_>cloudshu: it's in https://github.com/tc39/proposal-weakrefs
18:42:26  <keith_mi_>as an example
18:43:12  <keith_mi_>and yeah it's a "shadow" map
18:43:40  <keith_mi_>but that's much more expensive than having the VM iterate it for you since we already can
18:44:01  <cloudshu>oh i never scrolled that far down
18:44:04  <keith_mi_>As you now have 3 maps where you really only need one
18:44:11  <keith_mi_>LOL
18:44:16  <devsnek>can't you make the finalization group itself the map
18:44:28  <keith_mi_>devsnek: There's no find
18:44:31  <devsnek>aw
18:44:33  <keith_mi_>in finalization group
18:44:46  <keith_mi_>*I think*
18:45:20  <cloudshu>keith_mi_: yeah i mean i could be convinced with usage numbers but it just feels unlikely
18:46:17  <devsnek>i'm concerned that this api could expose data people thought was safely concealed
18:46:27  <cloudshu>how so?
18:46:34  <devsnek>if you assume people can't read a weakmap
18:46:36  <devsnek>because they can't
18:46:47  <devsnek>then suddenly someone runs your code on a new version of node
18:46:54  <keith_mi_>Yeah, it's possible it'd have to be a subclass of WeakMap
18:47:03  <keith_mi_>I'm sure Mark would feel that way
18:47:11  <ljharb>it'd definitely have to be
18:47:15  <devsnek>probably the first time i've ever agreed with mark
18:47:21  <keith_mi_>haha
18:47:41  <devsnek>i wouldn't mind a subclass
18:47:51  <ljharb>(it's a similar reason Map and Set should have used SameValue and not SameValueZero :-p)
18:48:02  <devsnek>Proxy.revokable, WeakMap.iterable
18:48:17  <keith_mi_>Is that the plan...
18:48:29  <keith_mi_>to have the subclass be a property of the main class
18:48:39  <devsnek>wow is it really revocable
18:48:39  <keith_mi_>so weird
18:48:56  <cloudshu>well revocable isn't a subclass constructor
18:49:03  <cloudshu>it's just like a function that returns a revocable proxy
18:49:20  <devsnek>nah i'd expect it to be like `IterableWeakMap` or smth
18:49:51  * keith_mi_goes to a meeting
18:50:23  <cloudshu>keith_mi_: wait hold up can you do proposals my controversial ideas because i don't want the headache
18:51:12  <cloudshu>1) mutable arguments.callStack that lets you programmatically unwind and do stack surgery
18:51:12  <keith_mi_>cloudshu: Is there a missing of in there because I don't understand you otherwise?
18:51:17  <ljharb>lol
18:51:35  <keith_mi_>🤮
18:51:45  <cloudshu>how else can we write real debuggers??
18:52:10  <cloudshu>one day i will make that proposal
18:52:14  <keith_mi_>use the inspector?
18:52:33  <devsnek>mutable global.stack
18:53:19  <ljharb>first you have to get stack in the first place
18:53:24  <cloudshu>2) Object.prototype.{castTo,castFrom}BigInt
18:54:13  <devsnek>O.O
18:54:32  * keith_mi_quit (Quit: My MacBook has gone to sleep. ZZZzzz…)
18:54:34  <cloudshu>one day people will come around to my ideas
18:55:03  <devsnek>i fear these ideas
18:55:36  <ljharb>cloudshu: lol cast an object from a bigint?
18:55:51  <cloudshu>yes, it will replace the guts of the this value
18:56:13  <cloudshu>it'll find the object whose pointer is the bigint value argument, and then replace guts
18:56:46  <ljharb>what's a pointer
18:57:12  <cloudshu>that's kind of a philosophical question
18:58:35  <ljharb>:-p
19:49:47  * laughinghanquit (Quit: My MacBook has gone to sleep. ZZZzzz…)
19:51:53  * laughinghanjoined
20:02:01  * cybaijoined
20:10:28  * Nimelrianquit (Ping timeout: 258 seconds)
20:43:04  * laughinghanquit (Quit: My MacBook has gone to sleep. ZZZzzz…)
20:46:51  * laughinghanjoined
20:48:13  * cybaiquit (Remote host closed the connection)
20:50:03  * laughinghanquit (Client Quit)
21:19:46  * itamarokquit (Remote host closed the connection)
21:20:21  * itamarokjoined
21:21:54  * itamarokquit (Remote host closed the connection)
21:22:11  * itamarokjoined
21:22:29  * cybaijoined
21:22:51  * itamarokquit (Remote host closed the connection)
21:23:56  * itamarokjoined
21:25:50  * itamarokquit (Remote host closed the connection)
21:26:45  * itamarokjoined
21:34:41  * keith_mi_joined
21:37:57  * laughinghanjoined
21:59:17  * keith_mi_quit (Quit: My MacBook has gone to sleep. ZZZzzz…)
22:03:35  * srl295joined
22:09:06  * keith_mi_joined
22:13:20  * cybaiquit (Remote host closed the connection)
22:32:28  * cybaijoined
22:36:43  * cybaiquit (Ping timeout: 245 seconds)
22:56:00  * cybaijoined
23:00:26  * cybaiquit (Ping timeout: 245 seconds)
23:05:25  * keith_mi_quit (Quit: My MacBook has gone to sleep. ZZZzzz…)
23:16:14  * keith_mi_joined
23:21:58  * keith_mi_quit (Quit: My MacBook has gone to sleep. ZZZzzz…)
23:28:41  * khyperiajoined
23:41:11  * laughinghanquit (Quit: My MacBook has gone to sleep. ZZZzzz…)
23:53:07  * laughinghanjoined