00:19:59  <rowbit>Hourly usage stats: [developer: 0, free: 11]
00:39:34  * AvianFluquit (Remote host closed the connection)
00:43:02  <isaacs>Raynos: pushed a "fix all the bugs" commit. review would be much appreciated if you feel so inclined. thanks!
00:59:44  * mike-djoined
01:14:04  * mike-dquit (Quit: mike-d)
01:19:59  <rowbit>Hourly usage stats: [developer: 6, free: 18]
01:29:19  * tilgoviquit (Remote host closed the connection)
02:11:04  * AvianFlujoined
02:17:00  <Raynos>isaacs: oh hi
02:17:38  <Raynos>isaacs: The alternative to a weakmap is a closure and no prototypes. The other alternative is emulated weakmaps that intercept valueOf and other hacks.
02:17:53  <Raynos>isaacs: I don't mind where the magic properties go to be honest
02:19:59  <rowbit>Hourly usage stats: [developer: 0, free: 27]
02:33:22  <Raynos>isaacs: I don't really follow most of readable-stream, it's complex.
02:40:03  * shykeschanged nick to zz_shykes
03:19:16  <Raynos>TOO MANY REPOS
03:19:22  <Raynos>REPOS WHY YOU SO MANY
03:19:59  <rowbit>Hourly usage stats: [developer: 1, free: 37]
03:55:47  * AvianFlu_joined
03:57:14  * AvianFluquit (Ping timeout: 240 seconds)
04:19:57  * stlsaintquit (Quit: leaving)
04:19:59  <rowbit>Hourly usage stats: [developer: 0, free: 26]
04:34:16  * AvianFlu_changed nick to AvianFlu
04:50:48  <Raynos>https://github.com/Raynos/proxy-stream#example
04:51:41  <Raynos>isaacs: https://github.com/Raynos/proxy-stream#example
04:51:55  <Raynos>The `transformation(chunk, next, end)` is a pretty solid primitive
05:09:01  * ryan_stevensquit (Quit: Leaving.)
05:19:59  <rowbit>Hourly usage stats: [developer: 0, free: 12]
05:49:17  * thatguydanjoined
05:50:02  * ryan_stevensjoined
06:10:48  <substack>oh no model.createStream() isn't emitting data :(
06:12:24  * saijanai_joined
06:12:25  * saijanai_quit (Excess Flood)
06:16:16  * AvianFlu_joined
06:16:18  * AvianFluquit (Read error: Connection reset by peer)
06:17:14  * AvianFlu_changed nick to AvianFlu
06:19:59  <rowbit>Hourly usage stats: [developer: 3, free: 70]
06:20:59  <substack>dominictarr_ZZZ: problem!
06:21:02  <substack>in scuttlebutt
06:21:11  <substack>the browser isn't synced!
06:24:16  <substack>FOUND IT
06:30:25  <substack>dominictarr_ZZZ: https://github.com/dominictarr/scuttlebutt/pull/8
07:00:47  <substack>I'm observing some more bugs where the state doesn't get synchronized too
07:00:53  <substack>but it should be ok for this demo
07:11:05  * thatguydanquit (Quit: thatguydan)
07:13:55  * AvianFluquit (Remote host closed the connection)
07:19:59  <rowbit>Hourly usage stats: [developer: 0, free: 61]
07:31:36  * ryan_stevensquit (Quit: Leaving.)
07:32:23  * dominictarr_ZZZquit (Ping timeout: 245 seconds)
07:41:45  * mikealjoined
07:45:45  * mikealquit (Read error: Connection reset by peer)
07:46:07  * mikealjoined
07:50:31  * mikealquit (Client Quit)
08:01:40  * shuaibquit (Quit: Textual IRC Client: http://www.textualapp.com/)
08:15:21  <mbalho>lxjs woowoo
08:19:59  <rowbit>Hourly usage stats: [developer: 0, free: 43]
08:44:16  <substack>for fucks sake cut the mic
08:44:41  * saijanai_joined
08:44:42  * saijanai_quit (Excess Flood)
08:54:05  <substack>haha I cut 4 examples
08:56:27  * st_lukejoined
08:56:48  * thatguydanjoined
08:58:13  <substack>still have 8 examples
09:00:36  * st_lukequit (Remote host closed the connection)
09:19:44  * thatguydanquit (Read error: Connection timed out)
09:19:59  <rowbit>Hourly usage stats: [developer: 4, free: 52]
09:20:50  * thatguydanjoined
09:24:25  <substack>so I've got all the examples down to 17 minutes
09:24:49  <substack>which leaves 3 minutes of slack for the intervening slides but hopefully I should go under that
09:25:00  <substack>so I can finish with a minute or two to spare
10:20:03  <rowbit>Hourly usage stats: [developer: 1, free: 36]
11:19:59  <rowbit>Hourly usage stats: [developer: 2, free: 22]
12:19:59  <rowbit>Hourly usage stats: [developer: 8, free: 37]
12:33:50  * thatguydanquit (Quit: thatguydan)
12:40:33  * dominictarr_ZZZjoined
12:40:36  * dominictarr_ZZZchanged nick to dominictarr
12:40:50  <dominictarr>substack, where did you put the examples?
12:43:31  * st_lukejoined
12:43:58  * st_lukequit (Remote host closed the connection)
12:50:22  * st_lukejoined
12:53:57  <dominictarr>nm, found it.
12:58:23  * st_lukequit (Remote host closed the connection)
12:59:58  * st_lukejoined
13:05:12  * st_lukequit (Ping timeout: 252 seconds)
13:19:18  <mbalho>dominictarr: ok so to do client side module caching i need to write that thing you mentioned that takes a package.json, a list of packages and versions you already have installed, and returns the missing modules
13:19:53  <mbalho>dominictarr: what should the return format be?
13:19:57  <dominictarr>mbalho, yes.
13:19:59  <rowbit>Hourly usage stats: [developer: 1, free: 74]
13:20:04  <mbalho>dominictarr: on the client im going to cache js in localstorage
13:20:49  <dominictarr>mbalho, check out the format of a browserify bundle when you pass the --debug option.
13:21:43  <dominictarr>you could return it as js, similar idea to jsonp, or you could just return a json structure.
13:22:34  <mbalho>i guess im trying to figure out how to store it on the client most efficiently
13:23:00  <mbalho>dominictarr: for example append only localstorage would have serialization/deserialization issues once the js got big
13:23:20  <mbalho>dominictarr: assuming im storing allll the js in one big blob
13:23:29  <dominictarr>hmm, I think you'd want to store each js file in it's own key.
13:24:05  <mbalho>dominictarr: i wonder what the spread is like between one huge file and many small files in terms of load perf
13:24:14  <mbalho>i guess it doesnt matter since localstorage is always blocking
13:24:49  <dominictarr>with --debug it sends a blob, but then it adds seperate <script> tags.
13:25:26  <dominictarr>you want to just do one request/response
13:26:51  <dominictarr>but store each js independently, so if one changes, you can request JUST the files that have changed, or been added.
13:26:55  <mbalho>--debug --prelude false is nice
13:27:14  <dominictarr>mbalho, that looks handy.
13:27:29  <dominictarr>mbalho, hey, by the way, you are at LXJS, right?
13:27:31  * saijanai_joined
13:27:31  * saijanai_quit (Excess Flood)
13:27:36  <mbalho>dominictarr: it'd be nice if there was a json output
13:27:45  <mbalho>dominictarr: yea im maxogden
13:28:05  <dominictarr>had a funny feeling you where
13:46:29  * st_lukejoined
13:55:41  * st_lukequit (Read error: Connection reset by peer)
14:08:59  * AvianFlujoined
14:11:25  <mbalho>substack: trying to hack json output into browserify right now by changing this section to respect a json flag https://github.com/substack/node-browserify/blob/master/lib/wrap.js#L282-314
14:11:42  <mbalho>substack: cant figure out what aliases, entries, and appends are though
14:13:06  <rowbit>/!\ ATTENTION: (default-local) paid account successfully upgraded /!\
14:13:07  <rowbit>/!\ ATTENTION: (default-local) joe@... successfully signed up for developer browserling plan ($20). Cash money! /!\
14:16:03  <mbalho>substack: the output format i'm shooting for is {"files": [], "aliases": [], {"request": "require.define("request")blahblahblahblahblah"}}
14:16:43  <mbalho>substack: i noticed this https://github.com/substack/node-browserify/blob/master/bin/cmd.js#L101-104
14:17:03  <mbalho>substack: and figured i should leave those in the json
14:17:18  <substack>yep
14:17:32  <substack>you can do all that stuff in a separate module completely from browserify
14:17:39  <substack>implementing a different bundle() function
14:18:10  <substack>browserify-json
14:19:43  <mbalho>substack: i dont want to do all the stuff here again though https://github.com/substack/node-browserify/blob/master/lib/wrap.js#L231-281
14:19:59  <rowbit>Hourly usage stats: [developer: 2, free: 78]
14:21:17  <substack>mbalho: how about a pull request that factors out .wrap() so it can take an optional callback with all the https://github.com/substack/node-browserify/blob/master/lib/wrap.js#L282-314
14:21:36  <mbalho>werd
14:21:58  <mbalho>i dont get why it cant be in browserify core though, its not like this is a generic solution in any way
14:22:23  <substack>it actually is
14:22:47  <substack>and an important thing for implementing bundles with static require() paths
14:23:00  <substack>and for generating prelude-less composable bundles
14:23:25  <substack>so you can just use browserify with a very minimal output footprint and so you can cat bundles together
14:24:26  <mbalho>imo browserify should return a json object and the browserify command line tool should be a separate thing that takes that json and formats it for stdout
14:24:36  <substack>correct
14:25:02  <substack>but to get to that point will require splitting things up into some more modules
14:26:06  <mbalho>substack: what are 'entries' and 'aliases' and 'appends'?
14:26:22  <mbalho>substack: https://github.com/substack/node-browserify/blob/master/lib/wrap.js#L292-312
14:26:55  <substack>browserify [entries]
14:27:08  <substack>aliases are a horrible thing that remaps require()s
14:27:38  <substack>appends is content to put after the bundle but inside the containing (function () {})()
14:27:48  <dominictarr>substack, are you speaking today, or tomorrow?
14:27:53  <substack>dominictarr: today
14:27:58  <dominictarr>what time?
14:28:08  <substack>17:10
14:28:54  <dominictarr>realtime.js ? on the schedule?
14:29:37  <substack>the last realtime.js talk
14:30:42  <dominictarr>oh, got it.
14:31:03  <dominictarr>trying to run your freestyle example
14:37:20  * shuaibjoined
14:43:15  * dominictarrquit (Ping timeout: 256 seconds)
14:48:51  * dominictarrjoined
14:50:24  * _sorensenjoined
14:53:13  * dominictarrquit (Ping timeout: 245 seconds)
15:00:26  * dominictarrjoined
15:05:32  * shuaibquit (Quit: Textual IRC Client: http://www.textualapp.com/)
15:19:59  <rowbit>Hourly usage stats: [developer: 4, free: 53]
15:49:40  * _ritchjoined
15:56:42  <guybrush>lol mbalho i saw you on ustream :D
16:19:59  <rowbit>Hourly usage stats: [developer: 0, free: 27]
16:31:48  <isaacs>Raynos: in your proxy-stream examples, you're calling proxy(stream, transformFunction /*(chunk,next)*/), yes?
16:31:59  <isaacs>Raynos: and next() may be called multiple times, or not at all.
16:32:03  <isaacs>Raynos: how does back pressure work?
16:32:15  <isaacs>Raynos: what if i have a transformation that takes >0 time?
16:43:33  * mike-djoined
16:47:07  * mike-dquit (Read error: Connection reset by peer)
16:47:49  * mike-djoined
16:56:56  * ryan_stevensjoined
17:00:11  * jibayjoined
17:01:29  * _sorensenquit (Ping timeout: 255 seconds)
17:05:44  * tphummeljoined
17:11:58  * dominictarrquit (Ping timeout: 245 seconds)
17:19:59  <rowbit>Daily usage stats: [developer: 70, free: 907]
17:20:00  <rowbit>Hourly usage stats: [developer: 10, free: 27]
17:21:17  * _sorensenjoined
17:21:52  * tphummelquit (Ping timeout: 248 seconds)
17:22:15  <isaacs>Raynos: https://github.com/isaacs/readable-stream/issues/16#issuecomment-8984382 Are you saying you have no users?
17:22:42  <Raynos>isaacs: yes, it's a badly phrased comment about making backwards breaking changes is easy if I have no users
17:23:25  <Raynos>isaacs: next can be called multiple or not at all. back pressure works by returning false from the function
17:23:39  <Raynos>if the transformation takes >0 time then call next later asynchronously and call end in the future
17:23:50  <Raynos>it's really transform(chunk, write, end)
17:23:55  <isaacs>oh, ok
17:24:09  <Raynos>for each transformation your effectively given a writable stream to put the new state in
17:24:26  <isaacs>so.. what happens if your transform takes time?
17:24:29  <Raynos>proxy-stream needs a lot of testing for edgecases because the transform function is used in pipe, write & read
17:24:54  <Raynos>isaacs: I don't understand. call next immediately or later or whatever
17:25:06  <isaacs>so you have something like function transform(chunk, write, end) { setTimeout(write.bind(null, chunk), Math.floor(10000 * Math.random())) }
17:25:22  <Raynos>that would work
17:25:25  <isaacs>right
17:25:31  <isaacs>so, my chunks come at a rate of 1/ms
17:25:42  <isaacs>how do i knwo that it's not ready to receive more?
17:25:48  <isaacs>does write() return false if there's soemthing pending?
17:25:51  <isaacs>is proxy-stream queing it up?
17:25:53  <Raynos>Interesting
17:26:05  <Raynos>proxy-stream queue's it up
17:26:09  <isaacs>setInterval(stream.write.bind(stream, chunk), 1)
17:26:18  <isaacs>i mean, you wouldn't do that of course.
17:26:21  <isaacs>not in a setInterval
17:26:35  <isaacs>it'd be a pipe, and the proxy-stream writable interface would have to return false to indicate that i should back off
17:26:41  <isaacs>and then emit drain when it's ready for more
17:27:17  <Raynos>yeah I havn't really thought about asynchronous transformations too much
17:27:28  <Raynos>not with back pressure preservance anyway
17:27:30  <isaacs>Raynos: my plan is to write a duplex interface, and a transform stream interface as well, where you have only to specify one method, and have all the buffering, water marks, etc. taken care of.
17:27:34  <Raynos>proxy-stream is also a mess because it does too much
17:27:47  <isaacs>Raynos: the issue is that, outside of synthetic userland streams, *most* transofmrations are asynchronous
17:28:04  <isaacs>parsers can be sync, i suppose.
17:28:04  <Raynos>it proxies write, read & pipe.
17:28:31  <isaacs>it would be soooooo nice to just say "Well, old readables are broken. sorry guys. rewrite everything"
17:28:34  <isaacs>but we're past that.
17:28:36  <isaacs>that would be a python3 move.
17:28:51  <isaacs>we're not python. we're ok with being dirty on the way to getting clean.
17:29:27  <isaacs>so, the path is, take on some horror bullshit shim complexity, try to convince everyone to use the new interface, and in a year maybe, remove the shims.
17:29:29  * tilgovijoined
17:29:46  <Raynos>o/
17:29:54  <isaacs>the real concern, at this point, is: Are we actually heading to something better?
17:30:04  <isaacs>or are we just increasing the number of things?
17:30:13  <isaacs>that's what keeps me up at night :)
17:30:17  <Raynos>isaacs: do you have a good strategy for end buffering?
17:30:38  <isaacs>Raynos: so, most streams in core will be backed by an async _read(n,cb) method, right?
17:30:52  <Raynos>I guess so
17:31:01  <isaacs>Raynos: since they're all either files, sockets, or "other" (crypto, zlib, etc.) which does some work in a thread.
17:31:24  <isaacs>with files, when read(2) returns 0 bytes, you're done.
17:31:45  <isaacs>with TCP streams, you get an explicit end
17:31:58  <Raynos>I mean
17:32:10  <isaacs>so, the _readableOptions.ended gets set to true
17:32:11  <Raynos>a.pipe(transform).pipe(b)
17:32:19  <Raynos>when a emits end it calls transform.end()
17:32:25  <isaacs>right
17:32:27  <Raynos>transform then needs to wait for all the async transformation to finish
17:32:31  <Raynos>and only then emit end to end b
17:32:35  <isaacs>right
17:32:37  <Raynos>how do you implement that end buffering
17:32:40  <isaacs>it only emits 'end' when its buffer is empty
17:32:45  <Raynos>because i'm making a mess of it
17:32:50  <isaacs>stream._readableOptions.ended = true
17:32:55  <isaacs>then, when the buffer is cleared, emit end
17:33:07  <isaacs>it might make more sense to call it _readableState
17:33:18  <isaacs>since it's actually a state tracker, not an options object.
17:33:34  <Raynos>I see
17:36:11  <isaacs>Raynos: oh, shoot, you were right, i don't have to shallow-copy options any more.
17:36:21  <isaacs>Raynos: since i'm putting everything on a different object anyhow.
17:36:24  <isaacs>my bad.
17:36:37  <isaacs>i just need to make sure it's an object at all: options = options || {};
17:43:04  <Raynos>yes
17:43:20  <Raynos>isaacs: https://github.com/Raynos/read-stream#example-queue
17:43:38  <Raynos>I've started pretending that a readable stream is simply a queue you can push stuff onto
17:43:58  <Raynos>which is essentially what it is because every readable stream has an internal buffer and read reads from that
17:44:37  <isaacs>Raynos: well, sure, except that it's not necessarily that :)
17:53:02  <Raynos>its simpler to think of it like that
18:02:15  <mike-d>isaacs: i'm sure this has been discussed, probably good reasons, but why is there no async require(…)
18:02:38  <isaacs>mike-d: because it's very complicated, and of very limited value
18:02:52  <isaacs>mike-d: we used to have require.async()
18:03:09  <isaacs>mike-d: there are surprisingly complex edge cases to handle.
18:05:59  * _ritchpart
18:06:29  <mike-d>isaacs: correct me if i'm wrong, and forgetting about the edge cases for a sec.. looking at the module code it's just fs that would need to be async… this could be useful for conditional inline requires
18:06:48  <isaacs>mike-d: how do you know when it's loaded?
18:07:00  <isaacs>mike-d: what if it does sync requires? what if it has other async requires? how do you know when allof those are loaded?
18:07:13  <isaacs>i mean, yeah, "forgetting about the edge cases" it's very easy :)
18:07:20  <isaacs>but that's a luxury i don't really have
18:12:29  <mike-d>isaacs: in my case it's for http routing and hot loading the route handlers, which are requires and there are a bunch of them, so the require happens on the first request to that route and since require uses fs.readFileSync it blocks… but yes loading deps would be a huge pain, got it
18:13:31  <isaacs>mike-d: how many routes is "a bunch"?
18:13:39  <isaacs>mike-d: ie, how many millions of routes do you have?
18:14:14  <mike-d>LOL 100 Billion Routes
18:14:16  <isaacs>mike-d: if your answer is less than 1000, just load them all up front synchronously
18:14:19  <isaacs>no, srsly.
18:14:30  <isaacs>i mean, you have multiple gigabytes of memory in your server, right?
18:14:52  <isaacs>it's better to just not hot-swap
18:15:09  <isaacs>like, have a cluster, and load them up-front at start time, and when you get new ones, do a rolling restart
18:16:04  <mike-d>isaacs: actually it's in the 1000s range, multi-tenant, lots of low traffic small sites is the use case
18:16:23  <isaacs>mike-d: yeah. no need for hot-swapping.
18:16:40  <isaacs>just assume that Can't Be Done, for now, and address it when and if you ever need it (which i'm betting you won't, actually)
18:17:01  <isaacs>when you need to, it's just js, just roll your own thingie.
18:17:09  <isaacs>not worth adding complexity and brittleness to core.
18:17:50  <mike-d>isaacs: i'm still gonna hot swap for other reasons, but i'll just take the sync hit, and since it's hosted at joyent it should be fine as disk io is fast
18:19:34  <Raynos>isaacs: I would like an async require in user land that doesn't do caching.
18:19:58  <Raynos>It's useful for hot reloading and it's bloody hard to implement correctly and it's hard coupled to the implementation of the undocumented module implementation
18:19:59  <rowbit>Hourly usage stats: [developer: 1, free: 26]
18:21:52  <mike-d>Raynos: let's hack it, i'm game, could we do it as a module without hitting core?
18:22:01  <Raynos>of course you can.
18:23:23  <mike-d>I thought so, also thought I was going to run into internal caching issues with require() as well and it looks like you're saying that would be the case
18:24:49  <isaacs>isn't require.js like, already exactly this?
18:24:51  <isaacs>or AMD?
18:24:55  <isaacs>i mean, there are implementations already
18:26:04  <mike-d>I believe require does async loading
18:26:15  <mike-d>require.js
18:30:53  <rowbit>/!\ ATTENTION: (default-local) sherry.zhou@... successfully signed up for developer browserling plan ($20). Cash money! /!\
18:30:53  <rowbit>/!\ ATTENTION: (default-local) paid account successfully upgraded /!\
18:33:35  <Raynos>isaacs: the problem is npm support
18:34:11  <Raynos>isaacs: It's also about watching file changes of source code and swapping in a new implementation of a module at run-time without taking the server down
18:34:17  <Raynos>it's about hot code reload
18:42:29  <mike-d>Raynos: exactly, in my case it's a little different, i'm using function swapping so that active requests can finish up on the old code while the new code is loaded and initialized (i'm accounting for async boostraping) and then when completed, the function is swapped and any new request hit the new handler code
18:43:49  <mike-d>Raynos: but I think module caching is going to cause pain
18:48:09  * tilgoviquit (Read error: Connection reset by peer)
18:59:00  <Raynos>https://twitter.com/Raynos2/status/251757566781177856
18:59:07  <Raynos>streams are like callbacks on STERIODS
19:04:59  <mike-d>Buffers are like Arrays on Steroids :D
19:06:13  <mike-d>Raynos: how are you "using streams as callbacks" do you have an example?
19:06:38  <Raynos>mike-d: https://github.com/Raynos/proxy-stream#example
19:12:17  <mike-d>Raynos: so instead of streaming bytes, you're streaming array elements
19:14:18  * thatguydanjoined
19:14:18  * thatguydanquit (Client Quit)
19:19:59  <rowbit>Hourly usage stats: [developer: 7, free: 46]
19:43:20  * tilgovijoined
19:58:31  * owen1quit (Ping timeout: 245 seconds)
20:19:59  <rowbit>Hourly usage stats: [developer: 0, free: 57]
20:37:39  <Raynos>isaacs: is _read just like util._extend. i.e. meant internally for making the node core DRY. Or is it part of the public API ?
20:37:55  <Raynos>mike-d: Something like that. but it's an infinite array
20:53:33  * owen1joined
20:54:42  <mike-d>Raynos: cool, are you streaming them one element at a time or streaming them in batches as they come in?
20:55:00  <Raynos>streams work one element at a time
20:55:06  <Raynos>it depends what you mean
20:56:32  <mike-d>one fn call per array element, is a chunk one element in the array or an array with all the elements you have at that time, sorry if it's a dumb question, did not pour through the code
20:58:31  <mike-d>Raynos: btw, check out require.cache, just log it, interesting stuff going on, also it could be safe to invalidate based on some limited research
20:59:17  <Raynos>mike-d: I know about that
20:59:35  <Raynos>mike-d: a chunk is a single thing.
20:59:53  <Raynos>mike-d: A chunk depends on what the underlying data sources gives you
21:00:16  <Raynos>mike-d: https://github.com/Raynos/events-stream#example events stream gives you a single DOM event thing for each iterator
21:00:17  <mike-d>i'm adding event emitter to my router as a hook for hot loading and will do some testing, yea, sorry was pretty sure you knew about require.cache, i'm a C programmer so node internals are kinda new to me
21:01:54  <mike-d>I see so if you pipe [1,2,3] into a stream a chunk is [1,2,3] and not three chunk calls 1 then 2 then 3
21:02:46  <mike-d>I also like your from to syntax, nice
21:03:32  <mike-d>readable and writable IMO are not intuitive, source dest is better
21:04:59  * zz_shykeschanged nick to shykes
21:07:42  * tilgoviquit (Remote host closed the connection)
21:09:22  * ryan_stevensquit (Quit: Leaving.)
21:19:59  <rowbit>Hourly usage stats: [developer: 0, free: 42]
21:32:37  * shykeschanged nick to zz_shykes
22:17:43  <isaacs>Raynos: _read is intended to be overridden, if you want to provide an asynchronous way of getting data.
22:18:00  <isaacs>Raynos: maybe it makes sense to rename it to readAsync or somethign?
22:18:21  <isaacs>Raynos: read2()? readLowlevel?
22:18:23  <isaacs>i don't know
22:18:42  <isaacs>the _ means to me, "internal function"
22:18:54  <isaacs>but some people read _ as "do not touch, do not override, pretend you can't see this"
22:18:58  <isaacs>pseudo-private
22:19:59  <rowbit>Hourly usage stats: [developer: 0, free: 35]
22:31:46  <Raynos>isaacs: I know how its supposed to be used. I mean is it going to publically documented?
22:43:28  <isaacs>Raynos: yes, it will be extremely documented.
22:50:21  <isaacs>Raynos: i'm finally starting to feel kind of good about this API
22:50:27  <isaacs>or at least, about this implementation.
22:50:37  <isaacs>i think the complexity is fairly well isolated.
22:51:05  <isaacs>it does suck that we have to support the existing patterns, but oh well.
23:01:07  * ryan_stevensjoined
23:04:13  * Raynosquit (Remote host closed the connection)
23:04:13  * niftylettucequit (Read error: Connection reset by peer)
23:04:14  * pikpikquit (Remote host closed the connection)
23:04:14  * sveisveiquit (Remote host closed the connection)
23:04:14  * ecquit (Remote host closed the connection)
23:04:28  * zz_shykeschanged nick to shykes
23:04:42  * ryanseddonquit (Read error: Connection reset by peer)
23:04:43  * duncanbeeversquit (Read error: Connection reset by peer)
23:05:18  * _sorensenquit (Ping timeout: 245 seconds)
23:07:19  * sveisveijoined
23:08:44  * pikpikjoined
23:12:21  * jibayquit (Quit: Leaving)
23:13:07  * sveisveiquit (Remote host closed the connection)
23:13:08  * pikpikquit (Remote host closed the connection)
23:19:59  <rowbit>Hourly usage stats: [developer: 2, free: 22]
23:22:20  * ryanseddonjoined
23:23:29  * ryanseddonquit (Remote host closed the connection)
23:33:16  * mike-dquit (Quit: mike-d)
23:37:29  * pikpikjoined
23:38:58  * ecjoined
23:46:31  * ryanseddonjoined
23:48:04  * sveisveijoined
23:48:59  * Raynosjoined
23:58:22  * ryan_stevensquit (Quit: Leaving.)