00:05:17  <akirose>dibs on being skipper
00:06:11  <devsnek>i've always wanted to drive a boat
00:07:52  <akirose>wait jk iโ€™ll be the professor
00:08:18  <TabAtkins>akirose: okay but i'm ginger
00:08:33  <akirose>wait who has to do the least amount of work
00:08:36  <akirose>i wanna be that person
00:08:40  <akirose>unless itโ€™s gilligan
00:08:41  <devsnek>passengers
00:08:43  <akirose>i have standards
00:09:03  <TabAtkins>the passengers are all dead
00:09:56  <akirose>that got dark
00:10:40  <devsnek>what if jsconf was on a boat
00:10:53  <akirose>what if jsconf was on a beach OH WAIT IT IS WAIKIKI BEACH
00:11:24  <devsnek>i was at that beach for a few hours like 8 years ago
00:41:32  * AtumTquit (Quit: AtumT)
01:01:27  * akirosequit (Ping timeout: 240 seconds)
01:01:39  * akirosejoined
01:24:02  * FireFlyquit (Quit: Goodbye)
01:25:15  * FireFlyjoined
02:49:28  * jwaldenquit (Quit: ChatZilla 0.9.92-rdmsoft [XULRunner 35.0.1/20150122214805])
03:09:38  * akirosequit (Ping timeout: 245 seconds)
03:10:01  * akirosejoined
03:24:50  * dpkquit (Ping timeout: 260 seconds)
03:30:09  * dpkjoined
03:31:27  <rkirsling>augh, manual spec linting really raises some tricky questions
03:32:38  <rkirsling>one can be fully pedantic or not give a damn, but there's not really an in between, short of a policy of only ever making surgical changes :(
03:35:37  <rkirsling>if we align on writing `"length"`, then that certainly implies `"prototype"` and should imply `"toString"`, but then you hit a phrase like
03:35:37  <rkirsling>> the `Math` property of the global object
03:36:27  <devsnek>put quotes
03:37:22  <rkirsling>but then the same for every built-in object?
03:37:54  <devsnek>oh like `is the initial value of the Promise property of the global object.`
03:38:01  <rkirsling>yessir
03:38:13  <rkirsling>that was exactly the sentence
03:38:34  <devsnek>i think quotes makes sense there
03:40:06  <devsnek>and then there's https://gc.gy/3910207.png
03:41:01  <rkirsling>yeah so `"length"` there comes from this patch of mine: https://github.com/tc39/ecma262/pull/1239
03:41:26  <devsnek>i would put quotes on name
03:41:50  <rkirsling>initially I tried to unify everything the other way because it seemed to be statistically the most consistent with existing practices
03:42:07  <rkirsling>but yeah, `"length"` easily implies `"name"` there, that's for sure
03:42:22  <devsnek>no quotes relies on conventional wisdom that properties are strings
03:42:30  <devsnek>i think the spec should be as explicit as possible
03:42:45  <rkirsling>problem is if you write `"Promise"` in one place, how can we not write it like that everywhere?
03:43:00  <rkirsling>this manual linting effort is only worth it if it's ultimately actually enforceable someday
03:43:05  <rkirsling>(at least in theory, haha)
03:43:19  <devsnek>`<word> property of`
03:43:35  <devsnek>it seems fairly consistent that they're always followed by "property of"
03:43:38  <devsnek>you could use that to lint
03:44:37  <rkirsling>yeah "property", "own property", "data property", "method", "static method", or "function" (at least in the cases where it's used to mean "static method")
03:45:00  <rkirsling>I mean that would be a policy to start with, for sure
03:46:39  <ljharb>quotes are for strings, which are property names
03:46:42  <ljharb>backticks are for identifiers
03:49:43  <rkirsling>right, so I was thinking a policy of just
03:49:43  <rkirsling>> `Object.prototype.hasOwnProperty`, `Object.prototype`, `Object`
03:49:43  <rkirsling>> `"prototype"`, `"hasOwnProperty"`
03:49:43  <rkirsling>would work
03:50:14  <rkirsling>but now `Object` seems to be brought into question by being a property of the global object
03:50:49  <devsnek>i think it depends on context
03:53:22  <rkirsling>another fun one is
03:53:22  <rkirsling>> The behaviour of the functions `acos`, `acosh`, `asin`, `asinh`, `atan`, `atanh`, `atan2`, `cbrt`, `cos`, `cosh`, `exp`, `expm1`, `hypot`, `log`,`log1p`, `log2`, `log10`, `pow`, `random`, `sin`, `sinh`, `sqrt`, `tan`, and `tanh` is not precisely specified here except to require specific results for certain argument values that represent boundary cases of interest.
03:53:43  <rkirsling>gonna be a whole lotta quotes goin' on :P
04:00:41  <rkirsling>but that one aside
04:01:49  <rkirsling>the very notion of an identifier comes into question, because `var x` can end up accessible as `window.x` or `global.x`
04:02:12  <rkirsling>so then what *isn't* a string becomes a tenuous line to draw?
04:04:42  <rkirsling>this was the whole thought process that went into my comment here: https://github.com/tc39/ecma262/pull/1239#discussion_r198345731
04:05:07  <rkirsling>it was kind of the only way I could think of every case without getting terrible dizzy ๐Ÿ˜‚
04:05:29  <rkirsling>er, s/kind of//
04:05:40  <rkirsling>and *terribly
04:06:12  <ljharb>i think that's why globals don't need quotes
04:06:15  <ljharb>because they're also identifiers
04:06:47  <rkirsling>that seems like a good way to put it
04:07:39  <rkirsling>so there's no way to construe `prototype` or `hasOwnProperty` as an identifier (unless you decide to make it one), but `Object` and company surely are
04:08:13  <rkirsling>so then you'd be okay with no quotes in "the `Math` property of the global object", ljharb?
04:08:28  <ljharb>personally yeah
04:09:01  <rkirsling>cool. I think that basically resolves my qualms then ๐Ÿ˜…
04:23:36  <jmdyck>I'd be inclined to expect quotes when you're explicitly giving a property key and not when you're not. E.g.: "the `"Math"` property of the global object" vs "the `Math` object". (Or "the function `acos`" vs "the `"acos"` property of the `Math` object")
04:25:58  * jmdyckquit (Remote host closed the connection)
04:36:27  <devsnek>i'm in agreement with that
04:39:13  <rkirsling>if jmdyck is suggesting it, he must have some way of viewing it as enforceable :D ...and yet he has disappeared :(
05:16:44  * aki_joined
05:17:27  * akirosequit (Ping timeout: 240 seconds)
05:17:27  * aki_changed nick to akirose
05:30:49  * cloudshuquit (Quit: Connection closed for inactivity)
06:47:48  <devsnek>anyone willing to champion a `has` operator? https://github.com/devsnek/ecma262/commit/42172ce2df217cd872683b36a037ea6661683fba
06:56:19  <ljharb>that's not a reserved word
06:56:31  <ljharb>so i think it'd need a NLT
06:59:24  <devsnek>ljharb: NLT?
07:00:35  <ljharb>no line terminator here
07:00:43  <ljharb>ie, to avoid ASI issues
07:01:16  <devsnek>oh
07:01:38  <ljharb>ie `'toString' \n in \n {}` works, but for `has` to work, it'd have to only allow non-newline-whitespace before and after the `has`
07:01:43  <devsnek>yeah
07:02:12  <devsnek>honestly i don't understand most of the grammar lol
07:22:49  * aki_joined
07:23:07  * akirosequit (Ping timeout: 240 seconds)
07:23:07  * aki_changed nick to akirose
07:27:30  <Bakkot>devsnek: a) really doesn't seem worth the syntax, but also b) there's a `has` handler on proxies which is a trap for the `in` operator, so that name is particularly unfortunate
07:28:33  <devsnek>Bakkot: i think it would be used quite often. Object.prototype.hasOwnProperty.call is quite a common pattern
07:28:48  <devsnek>i do recognize that the name isn't ideal
07:28:57  <devsnek>i'm open to suggestions :)
07:29:00  <Bakkot>yes, but we already have Object.prototype.hasOwnProperty.call
07:29:27  <Bakkot>(or `{}.hasOwnProperty.call`, as I think most people write it? or maybe just the code I read.)
07:30:48  <Bakkot>also, >95% of the places I see it used are for-in loops, which are adequately served by instead using `for (let name of Object.keys(obj)) {...}` instead of `for (let name in obj) { if (!{}.hasOwnProperty.call(obj, name)) continue; ... }`
07:31:06  <Bakkot>"would be used quite often" isn't really adequate justification for new syntax, IMO
07:31:28  <devsnek>it seems like such a common thing that js people do
07:31:35  <devsnek>not just in for-in loops
09:13:57  * Aquazijoined
09:29:57  * akirosequit (Ping timeout: 244 seconds)
09:30:04  * aki_joined
09:30:28  * aki_changed nick to akirose
10:35:29  * jmdyckjoined
11:37:10  * aki_joined
11:37:57  * akirosequit (Ping timeout: 252 seconds)
11:37:57  * aki_changed nick to akirose
12:00:04  * gibson042quit (Ping timeout: 240 seconds)
12:23:48  * ephemera_quit (Ping timeout: 252 seconds)
12:55:46  * ephemera_joined
13:41:18  <bradleymeck>Bakkot: hasOwnProperty is used for all sorts of dictionary usage https://github.com/nodejs/node/search?q=hasownproperty+path%3Alib&unscoped_q=hasownproperty+path%3Alib
13:42:51  * aki_joined
13:43:54  * akirosequit (Ping timeout: 252 seconds)
13:43:54  * aki_changed nick to akirose
14:04:56  <bradleymeck>i think `hasOwn` would also be a better name
15:48:36  * aki_joined
15:49:54  * akirosequit (Ping timeout: 272 seconds)
15:49:55  * aki_changed nick to akirose
15:58:13  <TabAtkins>bradleymeck: Wild-code usage notwithstanding, the behavior of *WebIDL* dictionaries is to look for properties, not own properties. So every web API that takes an options bag doesn't use hOP.
15:58:47  <bradleymeck>TabAtkins: that seems fine / i'm not proposing changing standard APIs
15:58:50  <TabAtkins>(Very intentional, to allow for passing "real" objects that store all their properties as getter/setter pairs on the prototype.)
15:58:54  <bradleymeck>even JS language does full lookups
15:59:04  <bradleymeck>and we shouldn't be changing that
15:59:08  <TabAtkins>Sure, just saying, "some wild code does this" isn't necessarily an argument for making it easier.
15:59:35  <bradleymeck>TabAtkins: well the alternatives to my desires have other blockers
15:59:38  <TabAtkins>Ideally, imo, we should aim for easier harmony in practices.
15:59:45  <bradleymeck>freezing primordials and the stupid overwrite problem
16:00:06  <bradleymeck>those are fine for me and fix a lot of my problems
16:00:44  <bradleymeck>i'm not arguing for/against, just stating that people *are* using this pattern
16:01:26  <TabAtkins>sure
17:55:38  * aki_joined
17:56:01  * jwaldenjoined
17:56:13  * akirosequit (Ping timeout: 246 seconds)
17:56:13  * aki_changed nick to akirose
18:50:52  * AtumTjoined
19:11:42  * cloudshujoined
19:20:38  * superamadeusjoined
19:21:06  * superamadeusquit (Client Quit)
19:22:05  * superamadeusjoined
19:22:53  * superamadeuspart
19:23:27  * superamadeusjoined
19:25:23  * superamadeusquit (Client Quit)
19:51:38  * superamadeusjoined
19:53:51  <superamadeus>Hello?
19:54:19  <superamadeus>Sorry, was just testing that I was able to register my nick.
19:54:25  <bradleymeck>success?
19:55:01  <superamadeus>Seems like it.
19:58:39  * superamadeusquit (Quit: Page closed)
20:03:16  * akirosequit (Ping timeout: 246 seconds)
20:03:30  * akirosejoined
20:19:17  <jmdyck>rkirsling: I think /`( data| own)? propert/ is a fairly good pattern for finding cases where the property key should be in quotes (according to the rule I suggested), and thus /[^"]`( data| own)? propert/ is fairly good for finding places where quotation marks should be added. But the complementary part of the rule would be hard to lint, I think.
20:28:17  <rkirsling>jmdyck: Sure. How about these?
20:28:17  <rkirsling>> the `toString` method
20:28:17  <rkirsling>> the parameter pattern used by ECMA-402 `toLocaleString` functions
20:28:17  <rkirsling>> This function provides a generic `toLocaleString` implementation for objects that have no locale-specific `toString` behaviour.
20:28:45  <rkirsling>think what you're saying would distinguish the first from the rest?
20:34:26  <devsnek>those are all referencing a specitic function
20:34:43  <devsnek>i wouldn't put quotes
20:36:14  <jmdyck>Yeah, I think I'd leave those as-is, sans quotation marks.
20:37:36  <rkirsling>or I guess I should be explicit and ask about the first as well
20:38:23  <rkirsling>do you view a difference between when `toString` is being described as a method versus when it's being described as a property?
20:38:43  <jmdyck>yes
20:38:58  <devsnek> yes
20:39:39  <rkirsling>okay, then that limits the scope drastically
20:41:36  <rkirsling>should be a considerably simpler task then, since I can just deal with stuff like
20:41:37  <rkirsling>> The RegExp prototype object does not have a `valueOf` property of its own; however, it inherits the `valueOf` property from the Object prototype object.
20:41:37  <rkirsling>and leave stuff like this alone
20:41:37  <rkirsling>> When the `valueOf` method is called, the following steps are taken:
20:45:47  <jmdyck>Note that the editors might have different ideas though.
20:46:39  <rkirsling>right
20:46:47  <rkirsling>we can start there though
20:47:22  <rkirsling>I'm also okay with what ljharb said yesterday; consistency is my only concern :D
20:48:10  <ljharb>the challenge is that it's fine to talk about these things in the abstract, but that doesn't mean that the consistency we come up with here will end up being ideal in the spec itself
20:56:10  <rkirsling>I don't think this discussion could be more concrete :P
20:56:31  <ljharb>lol
20:56:44  <ljharb>i mean like, the full scope of applying the consistency will probably end up in a few sub par results
20:57:01  <rkirsling>yeah
20:57:40  <ljharb>jmdyck: btw all your editorial changes are great, but PRs with tons of commits are harder to work with :-p
20:57:58  <rkirsling>my biggest worry would be attempting to enforce something that wouldn't be guessable to proposal champions writing new spec sections
21:02:09  * Aquaziquit (Ping timeout: 252 seconds)
21:02:10  * Wizekquit (Ping timeout: 252 seconds)
21:02:10  * TimothyGuquit (Ping timeout: 252 seconds)
21:03:39  * TimothyGujoined
21:03:40  * Aquazijoined
21:03:52  * Wizekjoined
22:09:22  * aki_joined
22:10:28  * akirosequit (Ping timeout: 245 seconds)
22:10:28  * aki_changed nick to akirose
23:15:20  <jmdyck>ljharb: it didn't start with tones of commits
23:15:43  <jmdyck>(or tons)
23:17:18  <ljharb>rofl i know
23:17:48  <ljharb>jmdyck: just pointing out that separate few-commit PRs are going to be easier/quicker to land :-)
23:19:28  <jmdyck>yeah, the problem is, I tend to need most of the commits in order to do downstream processing, so if I made them spearate PRs, I'd need to merge them locally. I tried that set up once, and it was painful.
23:22:12  <jmdyck>But in future, I'll try to do better to split off commits that I don't need downstream.
23:27:43  <ljharb>is there any way your validation tool could be added to the spec as a CI task?
23:27:47  <ljharb>to prevent further drift
23:35:16  <jmdyck>Maybe. Note that it isn't set up to render a pass/fail. It mostly just reports about things that *might* be problems, but might just be ways that the spec is legitimately doing something new/different.
23:48:13  <jmdyck>Mostly it generates reports, and I look to see how those differ from the previous reports, and investigate anything changes.
23:49:22  <jmdyck>So I don't know if that would work as a CI task.