03:57:45  * jmdyckquit (Quit: Leaving.)
06:32:51  * brabjoined
06:38:53  * not-an-aardvarkquit (Quit: Connection closed for inactivity)
07:03:40  * gskachkov_joined
07:28:56  * gskachkov_quit (Quit: gskachkov_)
07:29:33  * gskachkov_joined
07:48:38  * abernixjoined
08:16:31  * gskachkov_quit (Quit: gskachkov_)
08:26:03  * gskachkov_joined
10:25:09  * mylesborinsquit (Quit: farewell for now)
10:25:40  * mylesborinsjoined
11:14:59  * gskachkov_quit (Quit: gskachkov_)
11:28:59  * jmdyckjoined
11:33:57  * brabquit (Remote host closed the connection)
11:44:34  * gskachkov_joined
12:29:44  * brabjoined
12:48:07  * Fishrock123joined
12:49:21  * Fishrock123quit (Client Quit)
14:10:42  * abernixquit (Quit: Bye)
14:21:53  <littledan>No opinion on whether they should be added, but for context, I believe the objection was that brand checks aren't object oriented enough--you should be using method dispatch, not checks like tihs
14:22:21  <littledan>(OTOH if method dispatch is so great, why did ES6 add @@hasInstance?)
14:23:37  <littledan>I think a committee stance of trying to make everything brand-checkable indirectly but not exposing the functions doesn't make much sense. It'd be nice to pick one or the other
14:28:25  <littledan>rbuckton: +1 to the cancellation proposal
14:49:20  * gskachkov_quit (Quit: gskachkov_)
14:50:18  * brab`joined
14:53:41  * brabquit (Ping timeout: 240 seconds)
14:54:45  * brab`quit (Ping timeout: 255 seconds)
15:58:42  <ljharb>littledan: while i agree, the reality is that almost everything already is brand-checkable, so i don't think we *can* make the choice not to allow it
17:36:17  * tcarejoined
17:38:59  * rbucktonquit (Quit: Going offline, see ya! (www.adiirc.com))
17:39:08  * rbucktonjoined
17:47:39  * gskachkov_joined
18:00:39  * Fishrock123joined
18:09:55  * gskachkov_quit (Quit: gskachkov_)
18:12:39  * gskachkov_joined
19:06:47  * Fishrock123quit (Remote host closed the connection)
19:48:08  * gskachkov_quit (Quit: gskachkov_)
20:38:41  <dilijev>Is there a channel for ecma 402 discussion or does that take place here
21:03:08  <bterlson>dilijev: here, afaict
21:03:18  <bterlson>no Caridy here though
21:03:20  <dilijev>k, j/w
21:12:07  <dilijev>Does the spec expose a method to javascript to get which characters are supported for ID_START and ID_CONTINUE or would that just have to be in the form of an exploratory test?
21:12:53  <dilijev>obviously ideally this would be the currently-supported version of Unicode
21:13:31  <dilijev>but in reality there may be a lag in adopting it or errors in the data. for testing purposes, would be nice to know what are actually supported in a given engine.
21:16:16  * Fishrock123joined
21:16:46  * not-an-aardvarkjoined
21:39:26  <bterlson>dilijev: those classes are not exposed, also they come directly from Unicode
21:39:38  <bterlson>and the engine doesn't expose what version of Unicode is supported
21:39:40  <bterlson>maybe it should?
21:58:47  <dilijev>seems like a non-starter since it requires self-reporting and of course there /could/ be errors in the data from the library used
22:57:38  <Fishrock123>How hard would it be to add Math.TAU (A more exact PI * 2)? Been useful to me in past video game stuffs
22:57:49  <Fishrock123>I literally have no idea what the bar for adding Math constants might be
22:57:52  <bterlson>Fishrock123: it would likely be extremely easy
22:57:59  <bterlson>but search the notes
22:58:02  <bterlson>it's been asked for before
22:58:42  <Fishrock123>Also, uh... this just came to mind, will there be BigNum versions of these constants? Or is there only going to be BigInt-s?
22:58:57  <Fishrock123>maybe that's self answering
22:58:58  <bterlson>so far just BigInt
22:59:09  <TabAtkins>Fishrock123: How would it be useful? Math.PI is already accurate to far more digits than is necessary for anything physical, ever.
22:59:39  <TabAtkins>The one bit that you lose from Math.PI*2 vs Math.TAU is basically irrelevant?
23:01:01  <Fishrock123>lol, you're probably right
23:01:19  <Fishrock123>It just seems odd that SQRT2 and SQRT1_2 exist but something like that doesn't
23:01:42  <bterlson>those operations tend to be far more lossy for certain input values IIRC
23:02:08  <Fishrock123>in a theoretical would, it might make physics engines minimally more accurate, I guess?
23:02:11  <Fishrock123>hmm interesting
23:02:17  <Fishrock123>but those are constants
23:02:53  <Fishrock123>SQRT1_2 * 2 ~= SQRT2
23:02:54  <TabAtkins>Fishrock123: Like I said, you only need a handful of digits (literally - 5 will do) of pi for *anything* physical.
23:03:15  <Fishrock123>oh i don't disagree in practice
23:17:29  <Bakkot>TabAtkins: that's only true before you start doing long sequences of floating-point computations, which amplify error.
23:43:20  <dilijev>bterlson: meaning SQRT2 and SQRT1_2 are used in situations where the losses are more of a problem than PI and 2*PI?
23:45:11  <bterlson>dilijev: sorry I was confusing it with exp
23:45:15  <bterlson>and others
23:45:23  <bterlson>forgot about those constants :-P
23:50:14  <bterlson>https://github.com/tc39/proposal-cancellation
23:50:23  <dilijev>also I guess getting Math.TAU added to more languages and libraries furthers the agenda of The Tau Manifesto (http://tauday.com/)
23:51:21  <ljharb>dilijev: i would LOVE to get Math.TAU
23:52:07  <dilijev>I agree that the existence of the pair SQRT1_2 and SQRT2 is all the reason needed to add Math.TAU
23:52:10  <ljharb>i think someone's brought it up before tho, and it was rejected
23:52:16  <dilijev>if the bit matters in one pair, it matters in the other
23:52:53  <dilijev>easy enough to define it at a language level in whatever library needs it, for instance (i.e. easy to polyfill)
23:52:56  <ljharb>i want to add it because τ is an easier math concept to teach than π, but the reason i think that was given for not adding τ to JS was "not enough people learn τ in math"
23:53:02  <ljharb>so it's a chicken egg thing
23:53:31  <Fishrock123>^^^^^^
23:53:35  <Fishrock123>so much ^
23:53:54  <dilijev>s/language level/library level
23:54:02  <ljharb>if every web browser in the world has Math.TAU in the console, it'd be *so much nicer* to teach the concept.
23:54:23  <dilijev>also, for programmers with a strong math background this isn't a hard concept, that doesn't seem like much of an argument
23:54:38  <dilijev>for example, i heard/read about this literally just now and i love it already
23:54:53  <ljharb>i read about it a number of years ago, while i was tutoring an 8th grade girl in math
23:55:00  <dilijev>although maybe my assertion that i have a "strong math background" is thereby debunked
23:55:12  <dilijev>so let's say decent math background
23:55:15  <ljharb>i taught her about τ and was able to describe fractions in terms of τ, and *instantly* she understood her geometry homework
23:55:42  <ljharb>it was a triumph, both for teaching and for τ
23:55:49  <dilijev>that's very interesting. i love when stuff like that comes up and it's not so obvious to the indoctrinated but obviously better for learners
23:56:32  <dilijev>i ended up basically replacing an algorithms lecture with notes i typed up as a TA because i refactored a guess-and-check approach into an equation to solve
23:56:35  <ljharb>the fact that math experts often have to think about it for a second before answering how many radians a slice of pizza is in π, but that an elementary school student could do it instantly in terms of τ…
23:56:36  <dilijev>totally different level but still nice
23:56:46  <Fishrock123>I think I learned bout Tau from "PI2" in https://phaser.io/docs/2.6.2/Phaser.Math.html
23:57:02  <Fishrock123>indirectly
23:58:48  <dilijev>hmm come to mention it, i think PI2 is around in a lot of places already. I thought Java had it but I can't seem to find it now. I remember it being important in embedded systems or when using floats