00:15:14  * araijoined
00:48:52  * isHavvyGhostingjoined
00:51:21  * ephemera__quit (Quit: No Ping reply in 180 seconds.)
00:51:57  * isHavvyquit (Ping timeout: 240 seconds)
00:52:47  * ephemera_joined
01:06:30  * keith_millerjoined
02:16:33  * keith_millerquit (Quit: My MacBook has gone to sleep. ZZZzzz…)
02:35:40  * jdalton_joined
02:47:06  * ephemera_quit (Quit: No Ping reply in 180 seconds.)
02:48:38  * ephemera_joined
03:09:38  * keith_millerjoined
03:33:05  * srl295quit (Quit: Connection closed for inactivity)
03:56:16  * jwaldenquit (Quit: g'bye before I snipe myself even further)
04:09:16  * keith_millerquit (Quit: My MacBook has gone to sleep. ZZZzzz…)
04:45:57  * howdoijoined
04:54:57  * jdalton_quit (Quit: Connection closed for inactivity)
04:55:51  * jmdyckquit (Remote host closed the connection)
06:01:48  * rwaldronquit (Quit: ZNC 1.6.6 - http://znc.in)
06:24:01  * seishunjoined
06:44:46  * keith_millerjoined
07:11:27  * seishunquit (Disconnected by services)
07:11:33  * seishunjoined
07:16:17  * seishunquit (Ping timeout: 248 seconds)
07:16:56  * seishunjoined
07:21:31  * not-an-aardvarkquit (Quit: Connection closed for inactivity)
07:25:51  * seishunquit (Ping timeout: 255 seconds)
07:50:41  * araiquit (Remote host closed the connection)
09:11:28  * araijoined
09:15:40  * araiquit (Remote host closed the connection)
10:17:05  * vikash-afkquit (Remote host closed the connection)
10:25:08  * mylesborinsquit (Quit: farewell for now)
10:25:38  * mylesborinsjoined
10:53:43  * AtumTjoined
11:21:48  * vikash-afkjoined
11:26:04  * keith_millerquit (Quit: My MacBook has gone to sleep. ZZZzzz…)
12:12:57  * jmdyckjoined
13:25:18  * howdoiquit (Quit: Connection closed for inactivity)
13:51:56  * srl295joined
13:56:37  * keith_millerjoined
14:00:59  * rwaldronjoined
14:12:25  * jdalton_joined
15:15:46  <devsnek>it would be cool if there was something like Object.getOwnProperty
15:16:15  <devsnek>accessing without walking up the prototype chain
15:32:13  <ljharb>devsnek: you can do getOwnPropertyDescriptor, but then you have to call the getter conditionally, so yeah that would be nice
15:32:32  <devsnek>something like how Reflect.get works
15:32:51  <devsnek>Reflect.getButNoPrototypes
15:34:42  <ljharb>I’d also love a keyword for hasOwnProperty :-)
15:36:08  <devsnek>`has`
15:53:46  <bradleymeck_>`has` might be problematic since `has` trap on Proxy is for `in`
15:54:35  <bradleymeck_>I'd be lazy enough to just reuse `hasOwnProperty` : `o hasOwnProperty 'foo'`
15:55:11  <caitp>getOwn, hasOwn, putOwn
16:00:38  <bradleymeck_>caitp putOwn would have 2 operands though wouldn't it? XD
16:01:39  <caitp>Reflect.putOwn(target, name, value), I would think
16:01:41  <caitp>or setOwn
16:04:29  <bradleymeck_>oh, on Reflect
16:04:30  <caitp>if you wanted a cute syntax version, maybe something like `own a.b` -> "own" reference, so GetValue() and assignment don't traverse the prototype chain
16:04:48  * keith_millerquit (Quit: My MacBook has gone to sleep. ZZZzzz…)
16:05:10  <ljharb>reflect is only for proxy traps, ofc
16:05:57  <bradleymeck_>syntax gets some nice things by not being virtualizable so you don't have to deal w/ taint possibilities. the virtualizability requirement of APIs makes things hard to lock down vs other languages
16:06:17  <bradleymeck_>at least in my opinion
16:09:33  <caitp>own ({ __proto__: thingWithFooSetter }).foo = "setter not called";
16:10:19  <caitp>just have to find a way to make that not uh
16:10:28  <caitp>not break existing syntax
16:11:51  * howdoijoined
16:25:12  <devsnek>who needs existing syntax
16:25:55  <rkirsling>I think if you had just `own` there'd be too much temptation to read it as a verb :)
16:28:18  <caitp>well I guess you could use an operator instead of a keyword, but I think a keyword is easier to read
16:29:06  <caitp>not sure which operator would really say "own", other than $ maybe
16:29:14  <caitp>and I don't think that ones going to fly
16:36:40  <devsnek>{ own foo: bar }
16:36:55  <devsnek>lol that makes no sense ignore me
16:37:54  <Domenic>When would you ever use this?
16:39:05  <devsnek>getting a property without walking the prototype?
16:39:30  <caitp>defensive programming, assigning to a property if the prototype may have been modified
16:39:33  <devsnek>i could see it being used a lot in node core
16:40:15  <Domenic>I mean it's never used in the standard library
16:40:22  <caitp>sure it is
16:40:43  <caitp>CreateDataProperty
16:41:37  <caitp>probably most uses of [[DefineOwnProperty]]
16:42:10  <devsnek>i don't see the own set thing as much but
16:42:26  <devsnek>the want for not walking up prototypes on get is great
16:48:21  * keith_millerjoined
16:49:08  * keith_millerquit (Read error: Connection reset by peer)
16:49:14  * keith_mi_joined
16:50:02  * seishunjoined
16:55:01  <Domenic>I thought we were talking about get
16:55:09  <Domenic>The standard library never does a no-walking get
16:55:23  <Domenic>defineProperty is fine for a no-walking define
16:58:17  <devsnek>no-walking get would be useful with proxies
17:04:47  * bradleymeck_reread defineProperty spec after this convo and remembered that `Object.prototype.value = 1` makes lots of things not happy
17:06:42  <caitp>the true defensive programming style is probably to freeze intrinsic prototypes
17:07:12  <caitp>but in real world vms I think that slows down most accesses
17:07:44  <caitp>or at least most accesses which traverse to the top of the prototype chain
17:08:31  <bradleymeck_>caitp there are resistances to making defensive programming constraints since that is not how JS historically been evolved
17:10:36  <bradleymeck_>I would love a more defensible set of primitives around the object model, I'm not as concerned with overall general API defensibility if I can recreate APIs myself. Without safe ways to do this that cannot be virtualized we end up needing preprocessing of some kind / caches of primordials.
17:11:09  <bradleymeck_>but since I want to work on JS and not on some variant itself that causes friction. Such as my concerns with PrivateName
17:11:27  <bradleymeck_>* itself;
17:12:17  <caitp>I'm not really too concerned with this idea, other than more proposed language features and stdlib features -> more job security
17:12:26  <caitp>but that's selfish :p
17:14:58  <bradleymeck_>I just want to be able to write a sane defensible core for Node at this point. a variety of ways to get there, but without frozen realms or the like being fast/snapshotted etc. I think it is becoming harder as language features that are virtualized and are around the object model are added.
17:16:10  <devsnek>i think most people throwing code into the wild want that code to behave predictably
17:16:14  <devsnek>not just node core devs :p
17:18:31  <bradleymeck_>I mean... I have noticed I can hijack some parts of devtools if I get squirrely with things since they also inject code after stuff loads
17:20:49  * keith_mi_quit (Quit: My MacBook has gone to sleep. ZZZzzz…)
17:27:56  * keith_millerjoined
17:34:57  * seishunquit (Ping timeout: 248 seconds)
17:36:02  * keith_millerquit (Quit: My MacBook has gone to sleep. ZZZzzz…)
17:41:09  * seishunjoined
17:48:52  * keith_millerjoined
18:55:07  * keith_millerquit (Quit: My MacBook has gone to sleep. ZZZzzz…)
19:06:10  * keith_millerjoined
20:20:30  * jwaldenjoined
20:35:44  <linclark>when you're editing spec.html and adding new tables, how do you handle numbering?
20:36:07  <linclark>for example, if you want to insert a new section with a table between table-37 and table-38
20:36:32  <linclark>do you have to manually renumber all of the tables after #table-37?
20:36:38  <Domenic>linclark: you give them useful IDs, not numbered ones
20:36:42  <Domenic>The numbered ones were auto-generated
20:36:50  <Domenic>and are already outdated past a certain point
20:36:56  <linclark>ah, ok
20:36:57  <ljharb>Domenic: Object.assign does a walking get, but only on own keys, so it's effectively a no-walking get
20:37:10  <ljharb>as does Reflect.ownKeys
20:37:13  <Domenic>ljharb: kind of, not really in the face of proxies
20:37:32  <Domenic>You can always decide ahead of time what you're willing to do a walking get on
20:37:34  <ljharb>i mean, a proxy can override that, but a proxy would override a no-walking get too by returning a custom property descriptor
20:37:59  <Domenic>Yeah #table-40 is already Table 41
20:38:23  <Domenic>ljharb: what I'm saying is that a non-walking get is not a real operation; inventing it is very different from just deciding to only do walking gets on some subset of properties
20:38:55  <ljharb>Domenic: hm, maybe so. but it'd basically be GetOwnPropertyDescriptor + if accessor, call the getter, else return the value
20:39:07  <Domenic>Yeah, which is a completely unprecedented operation ;)
20:39:30  <ljharb>i feel like if it was available, it would have been used in Reflect.ownKeys and Object.assign and Object.entries/values, etc
20:39:41  <ljharb>it's unprecedented but that doesn't mean it wouldn't make more sense
20:42:29  <Domenic>I don't think we would have used a new type of get
20:42:37  <Domenic>One type of get is enough for a language, I think
20:42:53  <ljharb>that's what getOwnPropertyDescriptor is, tho
20:42:57  <devsnek>where is the specification for actually getting a property
20:43:05  <devsnek>the abstract operation just defers to O.[[Get]]
20:43:20  <ljharb>there's already two types of get, it's just that there's no abstract operation to wrap around the "accessor ? get() : value" logic
20:44:04  <devsnek>aha OrdinaryGet
20:44:07  <ljharb>actually https://tc39.github.io/ecma262/#sec-ordinaryget is almost that operation, lol
20:44:24  <ljharb>so "GetOwn" would just be "if hasOwn, OrdinaryGet, else return undefined"
20:44:35  <devsnek>OrdinaryGet is what [[Get]] calls though right?
20:44:39  <devsnek>thats like object[key]
20:44:42  <ljharb>yeah it wouldn't be that simple because of proxies
20:44:53  <ljharb>but something like that.
20:44:54  <devsnek>i'm very confused now
20:45:25  <ljharb>devsnek: https://tc39.github.io/ecma262/#sec-get-o-p is the typical Get abstract op
20:45:42  <devsnek>thats like a loop now
20:45:55  <devsnek>Get(o, p) calls o[[Get]]
20:45:58  <devsnek>which calls Get(o, p)
20:46:00  <devsnek>what is going on
20:46:00  <ljharb>devsnek: iirc O.[[Get]] calls the [[Get]] method, which defaults to calling OrdinaryGet
20:46:31  <ljharb>devsnek: https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots-get-p-receiver
20:46:36  <devsnek>i'm trying to figure out where the spec talks about walking up prototypes
20:46:48  <devsnek>i'm at that part now
20:46:51  <ljharb>devsnek: https://tc39.github.io/ecma262/#sec-ordinaryget line 3
20:47:07  <ljharb>that's where it's recursive until the parent is null
20:47:09  <devsnek>aha ok
20:47:37  <devsnek>so just add another arg to OrdinaryGet
20:47:52  <devsnek>if desc is undefined and walk is true
20:48:46  <ljharb>there's a number of ways that it could be done in the spec, that's certainly one
21:42:02  * seishunquit (Ping timeout: 268 seconds)
22:41:21  * keith_millerquit (Quit: Textual IRC Client: www.textualapp.com)
23:13:12  * not-an-aardvarkjoined
23:16:47  * joyeequit (*.net *.split)
23:19:40  * AtumTquit (Remote host closed the connection)