17:21:13  <piscisaureus>seems to work
17:29:37  * piscisaureusquit (Remote host closed the connection)
17:41:51  <leobalter>littledan: the summary helps a lot to navigate through the topics
17:41:54  <leobalter>thank you!
17:42:07  <littledan>thanks
18:43:59  * gskachkov_quit (Quit: gskachkov_)
18:49:19  * TehShrikequit (Quit: My MacBook has gone to sleep. ZZZzzz…)
18:55:02  * TehShrikejoined
19:01:37  * gskachkov_joined
19:43:07  <bterlson>what summary is this?
19:45:55  * bterlsontopic: ECMA TC39 | https://github.com/tc39 | +v's are your friendly neighborhood delegates! | Logs: http://logs.libuv.org/tc39/latest
19:47:42  <bterlson>also wow that bot updates fast
19:47:53  <bterlson>as in, instantly
19:51:26  * sebmckjoined
20:28:51  * not-an-aardvarkquit (Quit: Connection closed for inactivity)
20:46:16  <bterlson>I would love to make ALL steps in ECMA262 linkable. However, I need these step links to be stable across builds and modifications. One idea I'm toying with: each step gets a random slug that is then stored in a separate metadata file. Simple operations (straight add/remove) can automatically update the step map. More complex operations would require telling
20:46:17  <bterlson>Ecmarkup where steps moved. Any thoughts on this approach?
20:48:45  * Fishrock123quit (Remote host closed the connection)
20:50:50  <TabAtkins>bterlson: Bikeshed has a `source` operation for things that manipulate the source file itself. I've thought about having one option be to add IDs to various things. Then it's just there in your source, perfectly stable, and it's obvious when you need to re-run the tool.
20:50:59  <TabAtkins>(Or just manually add an ID to a new step, whatever.)
20:51:10  * Fishrock123joined
20:51:47  <bterlson>I don't want to clutter the source document since we're talking ~10k ids
20:51:56  <bterlson>and it will get hard to read the plaintext document
20:52:23  <bterlson>I went down this route first because I thought at very least we can have manual IDs for steps we know have in-bound references
20:52:42  <bterlson>but the syntax I was coming up with wasn't so good (either some special markdownalike for it, else an anchor/span with an id)
20:53:00  <bterlson>I agree it makes the updating logic substantially easier though, maybe that's the most important aspect
20:53:54  * tcarejoined
20:54:47  <TabAtkins>I think it is. Easy update logic means it's easy to reason about stabiity. And it's only a little clutter; easy enough to do something trivial like gensym some 4-character IDs or something (half a million possibilities!)
20:55:00  <TabAtkins>That's just 8 extra chars to each dfn.
20:55:34  <cloudshu>bterlson: how much bigger does that make the html file?
20:55:40  <cloudshu>bterlson: the final document
20:55:46  <bterlson>TabAtkins: it's not each dfn though, it's every step
20:55:51  <bterlson>in every algorithm
20:56:04  * sebmckquit (Quit: My MacBook has gone to sleep. ZZZzzz…)
20:56:08  <TabAtkins>Right, that's what I meant. Still. It's the equivalent of 1.5 extra words per step.
20:56:29  <cloudshu>bterlson: can JS intercept # values in the URL?
20:56:33  * sebmckjoined
20:56:38  <bterlson>cloudshu: umm, 10k *, say, 8 bytes ~80kb
20:56:53  <bterlson>or <0.1% increase in payload size
20:57:01  <bterlson>JS can indeed
20:57:07  <cloudshu>bterlson: is it possible to have JS that can interpret #alg-step-1 or whatever and jump to the right thing
20:57:14  <cloudshu>bterlson: oh <0.1% who cares, uuids for everyone
20:57:19  <TabAtkins>That's not stable, cloudshu
20:57:34  <bterlson>yeah stability is key
20:57:35  <TabAtkins>As in, if I link to #step-5, but the algo's been changed since then, it might be a different step.
20:57:48  <cloudshu>ah yes, stability
20:58:53  <TabAtkins>bterlson: Heck, at 10k you can use 3-char ids and have plenty of room to grow
20:58:56  <cloudshu>there's still a limit to the kind of modifications that can be made to an algorithm and still maintain stability
20:59:06  <TabAtkins>Just so long as your code can upgrade to 4-char automatically when necessary.
20:59:22  <TabAtkins>cloudshu: That's when you change the ID, so the link goes away.
20:59:52  <cloudshu>the side question is: how often do we edit algorithms in such a way that still maintains stability
21:00:10  <TabAtkins>In my experience (in CSS), often.
21:00:29  <cloudshu>i see
21:00:35  * sebmckquit (Ping timeout: 240 seconds)
21:05:28  * TehShrikequit (Quit: My MacBook has gone to sleep. ZZZzzz…)
21:07:56  * TehShrikejoined
21:09:20  <bterlson>steps might look like:
21:09:30  <bterlson>https://www.irccloud.com/pastebin/xmVsQ0tE/i
21:09:42  <bterlson>if the source document was updated
21:10:05  <TabAtkins>Yeah.
21:10:31  <TabAtkins>Also: Oooh, I should adopt that sorta syntax. Tho I think the usual method for adding classes/ids to Markdown constructs is to wrap them in {}
21:10:46  <TabAtkins>Like, headings are `### heading ### {#foo}`
21:10:52  <bterlson>{#step-xxx}?
21:10:54  <bterlson>ok
21:11:01  <bterlson>need to think about it
21:11:27  <TabAtkins>If you go that way, I can add similar syntax support to Bikeshed, and work on the source command to match.
21:17:12  * gskachkov_quit (Quit: gskachkov_)
21:43:10  * not-an-aardvarkjoined
22:08:01  <bterlson>is there an encoding scheme which packs into all printable utf-8 characters?
22:11:41  <TabAtkins>Yeah, base-65536
22:11:52  <TabAtkins>https://github.com/ferno/base65536
22:12:29  <TabAtkins>It optimizes for visible characters (Twitter, text editors), not necessarily bytes, but it doesn't do terribly there.
22:13:13  * Fishrock123quit (Quit: Leaving...)
22:14:00  <TabAtkins>That way you could drop it down to a single character and do fine. ^_^
22:18:50  <TabAtkins>(Or use ferno's base-32768 project, which is actually reasonably optimized for UTF-8, and very efficient in UTF-16.)
22:23:25  <tcare>that's pretty awesome :)
22:42:52  <bterlson>TabAtkins: so great, thanks :-D And yeah, I'm thinking two characters just for future proofings sake :-P Preserving alignment will be key.
22:43:02  <TabAtkins>Ah, sure.
22:43:08  <bterlson>which would you pick?
22:43:15  <bterlson>65536 or 32768
22:43:47  <TabAtkins>32768 seems reasonable. More likely to be installed fonts, better compression, almost no difference in string length (15b vs 16b per character)
22:44:02  <bterlson>that's what I was thinking
22:45:52  <bterlson>Domenic: thoughts about encoding step IDs directly into the source document (auto-generated by ecmarkup if not manually defined)?
22:50:08  <TabAtkins>bterlson: Don't forget to record in the doc what the highest step # used so far is, so you don't reuse previously-used ones that were deleted (thus rendering old links confusing).
22:50:35  <TabAtkins>Maybe just scanning all IDs and looking for the largest one fitting your pattern will work okay.
22:58:46  * TehShrikequit (Quit: My MacBook has gone to sleep. ZZZzzz…)
23:05:59  <bterlson>Is teh shrike a reference to the hyperion cantos I wonder?
23:06:44  <bterlson>TabAtkins: Maybe if I do base-32768 of length 3 I can just randomly generate and check for conflicts
23:07:22  <bterlson>which would be quite unlikely if my birthday paradox calculations are correct
23:07:37  <TabAtkins>At, uh, ~16 quadrillion possibilities, yeah, you're good.
23:07:56  <TabAtkins>2^45 values, so 2^23 before birthday paradox starts mattering
23:08:25  <TabAtkins>And a spec with 8 million steps in it would, uh, stress the browser even more than HTML/ES already do.
23:11:17  <TabAtkins>Tho "check for conflicts" is approximately as expensive as "look for highest value".
23:11:29  <bterlson>true
23:18:46  <bterlson>but I can't look for highest value - need some metadata in the document
23:18:53  <bterlson>maybe can just stuff it in the frontmatter
23:19:27  <TabAtkins>You can look for highest value, then skip ahead a few, just in case the previously-highest few steps were deleted.
23:19:34  <TabAtkins>Or, yeah, just track it in the frontmatter.
23:26:51  <bterlson>I'm vaguely uncomfortable with the build touching the input file
23:26:58  <bterlson>but maybe I just need to get over that
23:29:28  <TabAtkins>It's so so much better than trying to maintain an implicit connection between steps and a separate file ^_^
23:30:52  <bterlson>in some ways
23:31:04  <bterlson>it's also much likelier to accidentally clobber something you wanted to keep
23:31:32  <bterlson>especially in --watch mode where ctrl+s will trigger changes to the current file between 1 and 5 seconds later
23:34:59  <TabAtkins>Oh wow, no, do *not* automatically do this on build.
23:35:10  <TabAtkins>Modifying the source file is deffo a separate command.
23:36:34  <bterlson>ok, getting more comfortable