00:00:00  * ircretaryquit (Remote host closed the connection)
00:00:08  * ircretaryjoined
00:00:13  * dguttmanquit (Ping timeout: 240 seconds)
00:00:13  * dguttman_changed nick to dguttman
00:00:58  * timoxleyquit (Quit: Computer has gone to sleep.)
00:01:54  * timoxleyjoined
00:03:37  * crankquit (Ping timeout: 256 seconds)
00:05:28  * crankjoined
00:11:49  * fallsemojoined
00:25:12  <defunctzombie>is there a module which will backup shits to s3?
00:36:02  * ins0mniaquit (Ping timeout: 252 seconds)
00:52:32  * Benviequit (Ping timeout: 252 seconds)
00:55:02  <wolfeidau>chrisdickinson: I was thinking more of a view into the module
00:57:55  * yorickquit (Remote host closed the connection)
00:59:35  * Benviejoined
01:00:33  * evboguejoined
01:01:48  * jxsonquit (Ping timeout: 245 seconds)
01:05:25  * timoxleyquit (Quit: Computer has gone to sleep.)
01:08:30  * marcello3djoined
01:14:21  * mikealquit (Quit: Leaving.)
01:21:57  * evboguequit
01:27:58  * evboguejoined
01:41:26  <mbalho>has anyone else ever killed the node repl by trying to console.log objets that have huge typed arrays as keys?
01:41:40  <mbalho>oh wait it just finally logged out, it just took like 30 seconds
01:42:06  <mbalho>cause my typed array had 2.5 million keys
01:42:09  <mbalho>CARRY ON
01:42:09  <LOUDBOT>CUTTING AND PASTING IS COMPLICATED
01:42:41  <wolfeidau>mbalho: lol nice
01:42:47  <st_luke>mbalho: haha i usually end up just killing it
01:43:05  <st_luke>or were you on your kindle
01:43:46  <mbalho>nah im on the macbook, parsing minecraft level files
01:45:56  <st_luke>`pkill node` is in my muscle memory for when i do things like that
01:46:01  * timoxleyjoined
01:47:28  * thl0joined
01:48:24  * marcello3dquit (Remote host closed the connection)
01:56:39  <Raynos>Anyone have an idea on how I would check whether an incoming request is HTTPS ?
01:57:10  <Raynos>well whether an incoming request from a user is secure, i.e. all intermediate proxies are forwarding HTTPS traffic
02:04:40  * AvianFlujoined
02:04:58  <defunctzombie>Raynos: some proxies set certain headers
02:05:08  * tilgoviquit (Ping timeout: 252 seconds)
02:05:53  * mirkokquit (Ping timeout: 255 seconds)
02:06:43  * mirkokjoined
02:13:57  <mbalho>chrisdickinson: do you have a solution for zlib.inflate that works the same in browser + node?
02:14:19  <mbalho>chrisdickinson: using the japanese one i always seem to get 'unsupported compression method' when in node
02:14:53  * jibayquit (Remote host closed the connection)
02:16:08  * shamaquit (Remote host closed the connection)
02:16:19  <chrisdickinson>mbalho: zlib-browserify seems to work correctly
02:16:57  <mbalho>chrisdickinson: oh ok
02:17:14  * timoxleyquit (Ping timeout: 252 seconds)
02:20:19  * timoxleyjoined
02:28:08  * st_lukequit (Remote host closed the connection)
02:28:20  * tilgovijoined
02:34:42  * evboguequit
02:54:52  * thl0quit (Remote host closed the connection)
03:04:14  * dominictarrjoined
03:06:14  <dominictarr>Raynos: just woke up with an idea
03:06:20  <Raynos>IDEA
03:06:25  <Raynos>is it to rewrite node in LISP?
03:06:35  <dominictarr>what if you added a js type system
03:06:57  <dominictarr>except the only feature was argument length
03:07:20  <dominictarr>so that if you called a f3 with 1, 2 you got a partially applied function
03:07:52  <dominictarr>so the a -> b -> c style really made sense
03:08:38  <Raynos>so basically
03:08:43  <Raynos>curry all functions by default
03:09:10  <Raynos>this can be done by making everything in the "future / continuable / paaf" library curried by default
03:09:41  <dominictarr>yes, and maybe have a special way to handle callbacks / return values,
03:09:59  <dominictarr>WHAT IF: js had point-free style
03:17:44  <Raynos>point free ?
03:19:19  <Raynos>dominictarr: I've always wanted the function composition operator
03:23:14  <dominictarr>it's a way of writing haskell where you use only the function composition operator
03:34:35  <Raynos>dominictarr: do you have a good name for this damned function ( https://gist.github.com/Raynos/484693963b9ef499f446#file-callbacks-js-L3 )
03:34:40  <Raynos>the duplex one
03:35:21  <dominictarr>that is the Future -> Future one, right ?
03:36:01  <Raynos>yeah
03:36:21  <dominictarr>it's already confusing enough having only one thing called "Duplex"
03:36:41  <dominictarr>FutureFuture
03:37:18  <dominictarr>Future2
03:37:32  <AvianFlu>FUTURE 3: THE SECOND SEQUEL
03:37:32  <LOUDBOT>WHICH WINDOWS SEVEN EDITION IS RIGHT FOR YOU?
03:37:49  <Raynos>all three of those functions are the same thing basically
03:40:33  <Raynos>dominictarr: maybe pull-stream becomes easier if its `function stream(abort) { return function (cb) { ... } }`
03:43:57  * nicholasfjoined
03:48:01  <dominictarr>hmm, I think continuables is advantageous because it makes normal async functions more composable
03:48:15  <dominictarr>but does that extend to the way pull-streams work?
03:48:25  <dominictarr>given that pull-streams are stateful?
03:48:29  * nicholasfquit (Ping timeout: 255 seconds)
03:50:28  * dominictarrquit (Quit: dominictarr)
03:58:51  * tilgoviquit (Ping timeout: 260 seconds)
04:05:54  <Raynos>dominictarr: https://github.com/Raynos/pull-stream
04:05:54  * mikealjoined
04:08:45  * mikealquit (Client Quit)
04:11:22  * mikealjoined
04:15:48  * Ralt_joined
04:16:40  * Raltquit (Ping timeout: 258 seconds)
04:16:40  * Ralt_changed nick to Ralt
04:39:19  * gozalajoined
04:57:17  * mikealquit (Quit: Leaving.)
04:59:17  * douglaslassancejoined
04:59:31  * douglaslassancechanged nick to Asterokid
05:02:25  * AvianFluquit (Remote host closed the connection)
05:04:12  * wiwilliajoined
05:04:54  * jcrugzzquit (Ping timeout: 264 seconds)
05:18:01  * Domenic_joined
05:23:27  * dguttman_joined
05:25:08  * dguttmanquit (Ping timeout: 245 seconds)
05:25:08  * dguttman_changed nick to dguttman
05:32:13  * jjjjohnnnyjoined
05:34:00  * dguttmanquit (Quit: dguttman)
05:34:10  <defunctzombie>anyone got a widget or module that lets me do form data uploads (images) in the background via ajax or iframes?
05:34:40  <chrisdickinson>defunctzombie: is IE support a must have?
05:34:46  * chrisdickinsonis assuming yes.
05:34:47  <defunctzombie>chrisdickinson: yea
05:34:55  <defunctzombie>FormData is out
05:35:02  <defunctzombie>need something more generic
05:35:34  <defunctzombie>ive been googling around
05:35:37  <defunctzombie>and there is nothing
05:38:09  * jjjjohnn1yquit (Ping timeout: 276 seconds)
05:38:10  * hij1nxquit (Ping timeout: 276 seconds)
05:38:11  * kanzurequit (Remote host closed the connection)
05:38:12  * kanzurejoined
05:38:24  * dfggquit (Remote host closed the connection)
05:38:31  * dfggjoined
05:41:31  * AvianFlujoined
05:41:51  * AvianFluquit (Client Quit)
05:44:54  * dguttmanjoined
05:49:18  * dguttmanquit (Ping timeout: 245 seconds)
05:53:15  * dguttmanjoined
05:53:32  * dguttmanquit (Client Quit)
05:55:02  <defunctzombie>fuck it.. ill just use a hidden iframe haha
05:55:15  * timoxleyquit (Quit: Computer has gone to sleep.)
05:56:23  * jxsonjoined
06:01:18  * jxsonquit (Remote host closed the connection)
06:01:27  * wiwilliaquit (Remote host closed the connection)
06:01:46  * defunctzombiechanged nick to defunctzombie_zz
06:02:02  * wiwilliajoined
06:02:16  * wolfeidauquit (Remote host closed the connection)
06:08:53  * ralphtheninjaquit (Ping timeout: 255 seconds)
06:09:48  * fallsemoquit (Quit: Leaving.)
06:26:39  * mikealjoined
06:30:40  * dguttmanjoined
06:34:26  * dguttmanquit (Client Quit)
06:47:06  * mikolalysenkoquit (Ping timeout: 245 seconds)
07:06:10  * tilgovijoined
07:11:45  * jxsonjoined
07:13:46  * mikolalysenkojoined
07:16:26  * jxsonquit (Ping timeout: 252 seconds)
07:20:30  <mbalho>chrisdickinson: i see your git in browser and raise you minecraft in browser
07:20:35  <chrisdickinson>haha
07:20:56  <mbalho>chrisdickinson: step 1) port minecraft and git to browser. step 2) ???. step 3) profit!
07:21:24  <chrisdickinson>step 4) maybe someone at the whatwg / w3c will finally add native inflate / deflate apis!
07:21:29  <mbalho>lol srsly
07:21:54  <Domenic_>is that something you guys need?
07:22:01  <chrisdickinson>yes. yes. yes.
07:22:05  <mbalho>yes X 1000
07:22:15  <Domenic_>use cases?
07:22:23  <chrisdickinson>i'm writing git in the browser.
07:22:31  <Domenic_>welp
07:22:37  <mbalho>pngs, .gz files, git, i used it earlier to read minecraft level files
07:22:42  <chrisdickinson>but yeah
07:22:44  <Domenic_>ok i'll put in a word for that
07:22:44  <mbalho>basically any data that is encoded
07:22:50  <chrisdickinson>it's just a really great thing to have around.
07:23:00  <mbalho>its the same story as window.getRandomBytes
07:23:01  <Domenic_>if Yehuda is willing to take it on i'll have him email you guys, if not he hopefully knows someone who is
07:23:04  <chrisdickinson>especially as JS is expected to deal with larger and larger files
07:23:17  <mbalho>it was in browsers for like 10 years but was never exposed as an api
07:23:55  <chrisdickinson>the primary issue i'm having with inflate/deflate in native JS is that it's just not that fast.
07:24:23  <mbalho>yea itd be sweet to have node style require('zlib') streams
07:24:39  <Domenic_>yeah... but then we need to figure out streams in the browser...
07:24:43  <chrisdickinson>^^ but for the love of god actually expose the last inflate return code
07:24:56  <chrisdickinson>i have to do something incredibly awful because node doesn't ):
07:25:04  <mbalho>Domenic_: theres a spec for that already
07:25:15  <mbalho>https://dvcs.w3.org/hg/streams-api/raw-file/tip/Overview.htm
07:25:47  <Domenic_>mbalho: no, except maybe that XHR streaming thing?
07:25:48  <Domenic_>ah
07:25:56  <Domenic_>hmm that integrates further than I thought it did
07:25:56  <mbalho>that is a generic streams api
07:26:03  <Domenic_>is it good
07:26:04  <chrisdickinson>Domenic_: thanks for putting a word in, by the by!
07:26:07  <mbalho>the w3c needs a 'here is everything we are working on one one page'
07:26:11  * mikolalysenkoquit (Ping timeout: 256 seconds)
07:26:35  <mbalho>Domenic_: its good by w3c standards, e.g. you can abstract away the crappy api
07:26:42  <mbalho>Domenic_: its dart/node0.10 style pull streams
07:26:58  <Domenic_>mbalho: huh interesting. sounds good then.
07:27:12  <Domenic_>lol events though
07:27:28  <Domenic_>they just love their events
07:27:54  <Domenic_>and you do piping by using objectURLs I guess
07:28:13  <Domenic_>writable streams <-> things with .src
07:28:16  <Domenic_>weird
07:29:56  <Domenic_>so the zlib streams would like be instantiated with another stream?
07:30:20  <mbalho>i dunno what the api would be like
07:30:29  <mbalho>cause i dont really understand that streams draft yet
07:30:31  <mbalho>http://i.imgur.com/U0hRxZO.png
07:31:20  <Domenic_>it seems not horrible
07:32:14  <Raynos>Domenic_: events o/
07:32:18  <Raynos>way better then callbacks
07:32:20  <Raynos>who needs callbacks
07:32:25  <Raynos>you cant have any api
07:32:26  <chrisdickinson>http://cl.ly/image/2v0w3R372B2r/git-log.png
07:32:27  <Raynos>that takes a function
07:32:30  <Raynos>as an argument
07:32:34  <Raynos>that would be 100% un java
07:32:36  <mbalho>chrisdickinson: nice
07:32:44  <chrisdickinson>mbalho: also nice!
07:33:01  <chrisdickinson>i accidentally had both pages open in tabs and my laptop basically caught on fire, haha
07:33:07  <mbalho>lol
07:33:37  <mbalho>we just need to close this issue and then perf will be awesome enough to load multiple minecraft chunks at once https://github.com/shama/voxel-texture/issues/13
07:35:08  * hij1nxjoined
07:46:31  <Raynos>mbalho: theres a big flaw in that API btw
07:46:54  <Raynos>this -> https://dvcs.w3.org/hg/streams-api/raw-file/tip/Overview.htm#widl-StreamReader-result
07:47:15  <Raynos>a StreamReader has a result property that is the entire subset of the stream that has been read so far
07:47:33  <Raynos>it automatically concats chunks and stores it as a property thus you cant load large things
07:48:12  <Raynos>so we need to make a shit storm about it
07:48:24  <Raynos>I mean
07:48:30  <Raynos>productive email thread on the w3c
07:49:30  <Domenic_>Raynos: good catch
07:49:40  <Raynos>should I mail the thread?
07:49:57  <Domenic_>maybe
07:50:00  <Domenic_>who is even working on this stuff
07:50:11  <Raynos>> [email protected]
07:50:23  * cianomaidinjoined
07:50:25  <Domenic_>ah right they tell you where
07:50:26  <Raynos>the draft im reading is from today
07:51:34  <Domenic_>seems like a good idea
07:51:41  <Domenic_>i'm curious if anyone's implementing this
07:52:00  <Domenic_>oh
07:52:04  <Domenic_>it's already in IE10 O_o
07:52:09  <Domenic_>http://www.chromestatus.com/features
07:52:21  * mikolalysenkojoined
07:53:16  <Raynos>Oh ffs.
07:53:22  <Raynos>it also doesnt have pause
07:53:23  <Raynos>or back pressure
07:53:53  <Domenic_>is pause needed for pull streams?
07:53:59  <Raynos>no
07:54:06  <Raynos>but pull(subsetOfThing) is
07:54:09  <Raynos>all you can do
07:54:19  <Raynos>is say "read this stream" and it will emit process events
07:54:22  <Raynos>so its like old streams
07:54:24  <Raynos>with a resume method
07:54:27  <Raynos>and data events
07:54:29  <Raynos>and no pause
07:54:37  <Domenic_>uh pull(subsetOfThing) is
07:54:38  <Raynos>or at least a pause thats like "lawl no"
07:54:43  <Raynos>no its not
07:54:48  <Domenic_>also this seems vaguely backpressure like: https://dvcs.w3.org/hg/streams-api/raw-file/tip/Overview.htm#dfn-thresholdreached-event
07:54:56  <Domenic_>it isn't? all the read methods take a # of bytes param
07:55:14  <Raynos>thats for a builder
07:55:22  <Domenic_>no that's for the streamreader
07:55:38  <Raynos>threshold is for builder
07:55:43  <Domenic_>ah
07:55:43  <Raynos>stream reader has # of bytes
07:55:50  <Raynos>but that # of bytes means if you get this many terminate
07:55:53  <Raynos>so its like take(n)
07:56:14  * st_lukejoined
07:56:33  <Raynos>argh
07:56:40  <Raynos>I should search their mailing list
07:56:43  <Domenic_>how is take(n) different from read(n)
07:56:44  <Raynos>for previous threads
07:56:57  <Raynos>take(n) is read(n) && close()
07:57:06  <Raynos>it terminates the stream after n bytes
07:57:15  <Raynos>FUCK
07:57:19  <Raynos>I MISSED MY TRAIN >:(
07:57:19  <LOUDBOT>ACHIEVEMENT UNLOCKED: SAVED TO DISK
07:57:21  <Raynos>internet
07:57:24  <Raynos>y u y u
07:57:32  <Domenic_>:(
07:57:58  <Domenic_>huh yeah it seems like that is the case
07:58:01  <Domenic_>that's kind of dumb
07:58:04  <Domenic_>I think?
07:58:15  <substack>Raynos: oh no!
07:58:24  <substack>where are you stuck?
08:00:19  * cianomaidinquit (Quit: cianomaidin)
08:05:58  * mikolalysenkoquit (Ping timeout: 245 seconds)
08:20:18  <Raynos>substack: taxi get
08:29:00  * wiwilliaquit (Ping timeout: 264 seconds)
08:31:52  * mikolalysenkojoined
08:34:18  * st_lukequit (Remote host closed the connection)
08:36:02  * cianomaidinjoined
08:42:17  * cianomaidinquit (Quit: cianomaidin)
08:44:25  * wolfeidaujoined
08:45:29  * mikolalysenkoquit (Ping timeout: 255 seconds)
08:51:47  * dominictarrjoined
08:55:23  * mirkokquit (Ping timeout: 255 seconds)
08:55:33  * mirkokjoined
09:09:11  * stlsaintquit (Ping timeout: 245 seconds)
09:09:39  * Domenic_quit (Ping timeout: 260 seconds)
09:11:15  * mikolalysenkojoined
09:12:26  * dominictarrquit (Quit: dominictarr)
09:21:47  * jibayjoined
09:25:18  * mikolalysenkoquit (Ping timeout: 264 seconds)
09:39:26  * cianomaidinjoined
09:41:43  * dominictarrjoined
09:45:00  * ins0mniajoined
09:51:02  * mikolalysenkojoined
09:54:26  <dominictarr>Raynos: gozala what we really need to look to, really, for futuristic async, is stuff like http://www.loria.fr/~merz/papers/diss.html
10:04:28  * mikolalysenkoquit (Ping timeout: 246 seconds)
10:08:20  * cianomaidinquit (Quit: cianomaidin)
10:27:06  * ins0mniaquit (Ping timeout: 264 seconds)
10:32:03  * mikolalysenkojoined
10:41:26  * thl0joined
10:43:47  * mikolalysenkoquit (Ping timeout: 252 seconds)
10:59:28  * cianomaidinjoined
11:10:16  * mikolalysenkojoined
11:15:33  * cianomaidinquit (Quit: cianomaidin)
11:23:49  * mikolalysenkoquit (Ping timeout: 248 seconds)
11:27:58  * timoxleyjoined
11:33:21  * cianomaidinjoined
11:44:24  * nicholas_joined
11:49:51  * mikolalysenkojoined
11:50:00  * gozalaquit (Ping timeout: 264 seconds)
11:51:52  * marcello3djoined
11:55:46  * ins0mniajoined
11:57:28  * nichola__joined
12:01:01  * nicholas_quit (Ping timeout: 256 seconds)
12:01:53  * nichola__quit (Ping timeout: 252 seconds)
12:03:42  * mikolalysenkoquit (Ping timeout: 264 seconds)
12:07:02  <juliangruber>dominictarr: why does JSONStream emit arrays as whole chunks?
12:07:19  <juliangruber>stream.write('["foo",'); stream.write('"bar"]')
12:07:24  <dominictarr>what do you mean?
12:07:26  <juliangruber>emits ['foo', 'bar']
12:07:37  <juliangruber>instead of foo and bar
12:07:43  <dominictarr>hmm
12:07:58  <dominictarr>if you go JSONString.parse([true]) you will get that
12:08:26  <juliangruber>oh, sweet
12:08:39  <juliangruber>I had JSONStream.parse(true)
12:08:43  <dominictarr>you have to pass in the path matcher to the data you want out
12:08:50  <dominictarr>ah, that does nothing
12:09:07  <dominictarr>you can do JSONStream.parse('*') now, though
12:09:24  <dominictarr>or .parse('rows.*.value')
12:26:22  * ralphtheninjajoined
12:29:23  * mikolalysenkojoined
12:42:40  * mikolalysenkoquit (Ping timeout: 246 seconds)
12:48:06  * ins0mniaquit (Ping timeout: 264 seconds)
13:02:09  * tmcwjoined
13:10:18  * thl0quit (Remote host closed the connection)
13:10:54  * mikolalysenkojoined
13:16:17  * ins0mniajoined
13:21:13  * mikolalysenkoquit (Ping timeout: 240 seconds)
13:31:38  * fallsemojoined
13:35:44  * thl0joined
13:36:17  * timoxleyquit (Quit: Computer has gone to sleep.)
13:49:52  * fallsemoquit (Quit: Leaving.)
13:50:27  * gozalajoined
13:53:03  * mikolalysenkojoined
13:53:31  * yorickjoined
13:53:32  * yorickquit (Changing host)
13:53:32  * yorickjoined
13:58:04  * Domenic_joined
14:01:25  * mikolalysenkoquit (Ping timeout: 246 seconds)
14:13:58  * AvianFlujoined
14:20:33  * AvianFlu_joined
14:20:33  * AvianFluquit (Disconnected by services)
14:20:43  * AvianFlu_changed nick to AvianFlu
14:22:42  * timoxleyjoined
14:25:11  * defunctzombie_zzchanged nick to defunctzombie
14:26:01  * dguttmanjoined
14:28:20  * tmcwquit (Remote host closed the connection)
14:29:01  * mikolalysenkojoined
14:30:07  * mikealquit (Quit: Leaving.)
14:30:26  * fallsemojoined
14:31:11  * tmcwjoined
14:40:26  * mikolalysenkoquit (Ping timeout: 245 seconds)
14:45:22  * Domenic__joined
14:46:00  * Asterokidquit (Read error: Connection timed out)
14:48:33  * dguttman_joined
14:48:55  * dguttmanquit (Read error: Connection reset by peer)
14:48:57  * dguttman_changed nick to dguttman
14:51:48  * douglaslassancejoined
14:55:51  * douglaslassancequit (Ping timeout: 245 seconds)
15:02:54  * Domenic__quit (Remote host closed the connection)
15:06:01  * douglaslassancejoined
15:07:12  * mikolalysenkojoined
15:14:45  * fotoverite_joined
15:16:01  * mikealjoined
15:16:11  <juliangruber>works :)
15:16:24  <juliangruber>dominictarr: what was your autocomplete / input+dropdown module called again?
15:16:47  <dominictarr>hmm, I didn't write one since AGES ago
15:17:10  <dominictarr>query-stream ?
15:17:33  * fotoveritequit (Ping timeout: 258 seconds)
15:17:33  * fotoverite_changed nick to fotoverite
15:17:43  <dominictarr>are you sure it was me? chrisdickinson and defunctzombie both wrote one recently, i think
15:18:50  <juliangruber>ah, exactly
15:18:53  <juliangruber>ok, that's not what I want
15:19:26  <juliangruber>I'll have a look at the others
15:21:36  <juliangruber>chrisdickinson defunctzombie: how are your autocomplete/dropdown modules called?
15:21:45  <defunctzombie>juliangruber: typeahead
15:23:31  <juliangruber>defunctzombie: looks good!
15:27:50  * mikealquit (Quit: Leaving.)
15:33:17  * Domenic__joined
15:39:48  <juliangruber>defunctzombie: does typeahead work? the dropdown is off in the tryme and on my page it doesn't show at all
15:41:13  * Domenic__quit (Ping timeout: 240 seconds)
15:41:33  <juliangruber>oh, it shows, but in the wrong position
15:41:58  <defunctzombie>juliangruber: it should work
15:42:03  <defunctzombie>ive used it and I think Raynos uses it
15:43:13  <juliangruber>ah, I should include style.css
15:50:16  * Benviequit (Ping timeout: 246 seconds)
15:52:29  <tmcw>are there any well-tested non-jquery ajax libraries?
15:52:50  <defunctzombie>juliangruber: the style.css is meant to be used with npm-css
15:52:54  <juliangruber>tmcw: hyperquest
15:52:55  <defunctzombie>which auto-namespaces
15:53:01  <defunctzombie>so the styles do not leak
15:53:04  <juliangruber>defunctzombie: I don't want to use npm-css
15:53:13  <juliangruber>just prefixing all the things works
15:53:26  <juliangruber>as long as the prefix is unique
15:54:03  <tmcw>juliangruber: looks cool, but the focus is almost entirely on not breaking in ie
15:54:18  <juliangruber>tmcw: works in ie8
15:54:22  <juliangruber>tmcw: didn't test below
15:54:40  <owen1>nodeup is down
15:54:50  * dominictarrquit (Quit: dominictarr)
15:57:26  * dguttman_joined
15:57:27  <juliangruber>haha
15:57:34  <juliangruber>they're on jitsu i guess?
15:57:50  * dguttmanquit (Ping timeout: 252 seconds)
15:57:50  * dguttman_changed nick to dguttman
15:57:54  <juliangruber>you they are
15:57:55  * cianomaidinquit (Quit: cianomaidin)
16:00:00  * Benviejoined
16:00:00  * Benviequit (Client Quit)
16:04:13  <mikolalysenko>any suggestions for how to make this faster: https://gist.github.com/mikolalysenko/5311694
16:08:00  * Domenic__joined
16:08:01  <guybrush>oh thats the quake "fast" sqrt^-1
16:09:17  * Domenicjoined
16:09:26  * Domenicquit (Client Quit)
16:09:44  * Domenic___joined
16:10:27  * dguttman_joined
16:11:23  * dguttmanquit (Ping timeout: 240 seconds)
16:11:23  * dguttman_changed nick to dguttman
16:13:56  <mbalho>Raynos: ahh yea you should email the list and be all DONT CONCAT EVERYTHING!
16:15:50  * jcrugzzjoined
16:18:31  * shamajoined
16:20:22  <mikolalysenko>guybrush: yep. but it turns out that in JS calling 1.0 / Math.sqrt() is faster (and more accurate)
16:21:01  <guybrush>mikolalysenko: hm i looked at the code for some time now, no idea how that could be made faster
16:21:34  <guybrush>also i remember @tojiro tweeting about trying to implement this in js but didnt work out
16:22:14  * douglaslassancechanged nick to Asterokid
16:22:45  <guybrush>i wonder if it would make a difference in asmjs :p
16:25:10  <mikolalysenko>maybe
16:25:27  <mikolalysenko>I think it might work in asm.js, but I am also a bit skpetical that it is even faster in C on modern architectures
16:25:41  <mikolalysenko>where you usually have an rsqrt instruction in silicon
16:32:32  * yorickquit (Read error: Connection reset by peer)
16:40:17  * dguttmanquit (Quit: dguttman)
16:41:50  * dguttmanjoined
17:06:27  * stlsaintjoined
17:06:27  * stlsaintquit (Changing host)
17:06:27  * stlsaintjoined
17:06:45  * Asterokidquit (Quit: Leaving...)
17:08:19  * timoxleyquit (Quit: Computer has gone to sleep.)
17:10:56  * jxsonjoined
17:11:34  * jxson_joined
17:16:03  * jxsonquit (Ping timeout: 276 seconds)
17:18:41  <chrisdickinson>so, cloning *sort* of works in browser
17:19:01  <chrisdickinson>but it totally chokes on "large" objects (i.e., when someone commits pngs to their repo)
17:19:10  <chrisdickinson>(large being >1mb)
17:21:22  * jxson_quit (Remote host closed the connection)
17:21:50  * jxsonjoined
17:27:23  <mikolalysenko>I wish there was a sort for js where you could define custom move operations
17:27:31  <mikolalysenko>so you could do sorts on structures stored in typed arrays
17:27:41  <mikolalysenko>any takers on implementing this?
17:30:35  <mbalho>crossfilter.js is that
17:30:46  <mbalho>its just quicksort in a typed array
17:30:48  <mbalho>IIRC
17:34:23  <mikolalysenko>hmm
17:34:36  <mikolalysenko>can you make custom structures and sort them using cross filter?
17:35:57  <mbalho>if not you could probably use the pieces https://github.com/square/crossfilter/tree/master/src
17:36:20  <mikolalysenko>interesting...
17:36:37  <mikolalysenko>putting something like this together would be quite a proejct but could be very worthwhile
17:36:50  <mikolalysenko>I think fast sorting is the number one feature from c++ that I miss in js
17:36:59  <mikolalysenko>followed by decent red-black trees
17:40:32  * timoxleyjoined
17:41:56  * CryptoQuickjoined
17:42:36  * dguttmanquit (Quit: dguttman)
17:43:32  * xaqjoined
17:57:18  * Domenic__quit (Remote host closed the connection)
17:57:58  <isaacs>DURR!!! YOU DONT YOU KNOW DONT INFINITE MONKEY SHAKES NUMBER SPEARS
17:57:58  <LOUDBOT>IF YOUR HEAD IS A PENIS THEN I AM GOING TO STUFF THIS AXE UP YOUR URETHRA.
17:58:07  <isaacs>LOUDBOT: search infinite
17:58:08  <LOUDBOT>isaacs: <WinstonSmith:##turtles> INFINITE TURTLE SYNDROME
17:58:09  <isaacs>LOUDBOT: search infinite
17:58:10  <LOUDBOT>isaacs: <apeiron:##church-of-loudbot> IDIOCY IS INDEED AN INFINITE RESOURCE
17:58:15  <isaacs>LOUDBOT: search spears
17:58:16  <LOUDBOT>isaacs: <spiffytech:#ncsulug> NOW I CAN LISTEN TO BRITNEY SPEARS AND BACKSTREET BOYS ALL DAY IN SECRET
17:58:17  <isaacs>LOUDBOT: search spears
17:58:18  <LOUDBOT>isaacs: <Levia:#peltkore> BRITNEY SPEARS' BABY TO ENTER PRE-HAB
17:58:27  <isaacs>LOUDBOT: search infinite monkey shakes
17:58:28  <LOUDBOT>isaacs: <isaacs:#stackvm> DURR!!! YOU DONT YOU KNOW DONT INFINITE MONKEY SHAKES NUMBER SPEARS
17:58:31  <isaacs>LOUDBOT: twitlast
17:58:32  <LOUDBOT>http://twitter.com/LOUDBOT/status/319871620929966080 (isaacs/#stackvm)
17:59:36  * jcrugzzquit (Ping timeout: 276 seconds)
18:02:33  <mikolalysenko>what?
18:11:06  * Domenic__joined
18:23:27  * xaqquit (Remote host closed the connection)
18:28:07  * wiwilliajoined
18:32:19  * yorickjoined
18:37:46  <Raynos>defunctzombie: how do you handle I18N ?
18:38:06  <defunctzombie>Raynos: f2k i18n
18:38:16  <Raynos>defunctzombie: how I translation?
18:38:28  <defunctzombie>I don't handle it currently
18:39:11  <Raynos>oh
18:39:13  <Raynos>:(
18:39:51  * timoxleyquit (Quit: Computer has gone to sleep.)
18:41:45  * AvianFluquit (Remote host closed the connection)
18:44:31  <defunctzombie>yea :/
18:44:41  <defunctzombie>not enough people involved yet to be able to do it
18:49:54  * Domenic_quit (Ping timeout: 264 seconds)
18:49:54  * Domenic___changed nick to Domenic_
18:54:48  * jcrugzzjoined
18:58:34  * dguttmanjoined
19:20:31  * AvianFlujoined
19:20:38  * timoxleyjoined
19:47:11  * thl0quit (Read error: Connection reset by peer)
19:47:12  * Domenic__quit (Read error: Connection reset by peer)
19:47:33  * Domenic__joined
19:48:05  * thl0joined
19:54:30  * xaqjoined
20:04:38  * AvianFluquit (Read error: Connection reset by peer)
20:04:55  * AvianFlujoined
20:11:18  <jesusabdullah>http://www.oneweirdkerneltrick.com lolwut
20:11:22  <jesusabdullah>this one's for you substack
20:15:53  <substack>isaacs: https://github.com/substack/destroyer
20:17:49  <substack>jesusabdullah: "end slavery to the Bayesian monopoly"
20:21:09  <substack>http://www.meteor.com/blog/2013/04/04/meteor-060-brand-new-distribution-system-app-packages-npm-integration
20:22:06  <substack>the package.js stuff is still weird though
20:24:02  <defunctzombie>does no one have a good way to cross browser upload things?
20:24:16  <defunctzombie>it is 2013 and we have no solutions to this that don't suck?
20:24:37  * AvianFlu_joined
20:24:56  * AvianFluquit (Read error: Connection reset by peer)
20:26:44  * cianomaidinjoined
20:26:53  * xaqquit (Ping timeout: 240 seconds)
20:28:57  * nicholas_joined
20:29:46  <Domenic__>if you need ie<10 support no
20:29:49  <Domenic__>you do iframes
20:30:05  <Domenic__>and lose out on nice things like error codes -_-
20:30:31  <Domenic__>we are using https://github.com/blueimp/jQuery-File-Upload, it is not great
20:31:32  <mikolalysenko>what is the best npm module for "deep equals"?
20:31:36  * AvianFlu_changed nick to AvianFlu
20:31:47  <substack>mikolalysenko: https://npmjs.org/package/deep-equal
20:32:01  <mikolalysenko>substack: thanks
20:33:04  * Domenic__quit (Remote host closed the connection)
20:33:33  * Domenic__joined
20:34:26  <Raynos>defunctzombie: upload?
20:34:31  <Raynos>just use XHR
20:34:44  <defunctzombie>devaholic: I would like error codes
20:34:49  <defunctzombie>devaholic: sorry, bad tab
20:34:55  <defunctzombie>Domenic_: I would like error responses
20:35:13  <defunctzombie>Domenic_: I saw the jquery thing.. looks like trash.. does it do error responses?
20:35:21  <defunctzombie>Raynos: file data is different
20:35:32  <defunctzombie>Raynos: I am talking about multipart requests
20:36:06  <Raynos>cant you just send a blob or file?
20:36:19  <Raynos>http://www.w3.org/TR/XMLHttpRequest/#dom-xmlhttprequest-send
20:37:22  <defunctzombie>Raynos: you have to be able to get the file blob
20:37:36  <Raynos><input type="file">
20:38:01  <Raynos>`input.files`
20:40:12  * Domeni___joined
20:40:49  <defunctzombie>Raynos: does that work in IE?
20:41:09  <Raynos>defunctzombie: you can either support IE or have nice things. not both
20:41:21  <defunctzombie>Raynos: I need to support IE9 and 10 I think
20:41:29  <defunctzombie>I just want it to fucking work :'(
20:42:37  <Raynos>i dont think ie9 will do it
20:42:41  <Raynos>but you can check in a fiddle
20:42:56  * wiwilliaquit (Ping timeout: 245 seconds)
20:45:30  * cianomaidinquit (Quit: cianomaidin)
20:45:54  <chrisdickinson>ie9 won't, according to caniuse
20:46:08  * tmcwquit (Remote host closed the connection)
20:46:32  <chilts>heh, SF weather is like Wellington's ... cloudy and slightly chilly
20:51:19  * tmcwjoined
20:51:55  * cianomaidinjoined
20:52:32  * tilgoviquit (Remote host closed the connection)
20:52:44  * cianomaidinquit (Client Quit)
20:53:35  * dominictarrjoined
20:53:37  <mikolalysenko>another module question: is there a library that does something like C++'s iota()?
20:53:45  <mikolalysenko>the module called "iota" definitely does not
20:54:00  <mikolalysenko>basically, I want something that just creates an array of sequential integers
20:54:13  <mikolalysenko>like: iota(3) = [0,1,2]
20:54:32  * cianomaidinjoined
20:54:52  <gozala>Raynos: dominictarr: https://gist.github.com/Gozala/5314269
20:55:18  <gozala>I've being thinking about hybrid push & pull style signals / streams
20:55:38  <CoverSlide>so, like python / ruby ranges?
20:55:47  <CoverSlide>i think i've seen a module like that
20:56:19  <CoverSlide>although i think a for loop is how they'd get implemented anyway
20:56:28  <CoverSlide>in like 3 lines of code
20:56:44  <chilts>depends whether you want pre-generate them all, or do it just in time :)
20:57:04  <chilts>I suspect mikolalysenko wants to pregenerate them
20:59:02  <mikolalysenko>yeah, I know it is not so much code to do
20:59:36  * cianomaidinquit (Quit: cianomaidin)
20:59:42  <mikolalysenko>but I'd rather have a function to generate those arrays, since it makes your code shorter and avoids distractions when writing stuff
21:00:05  <mikolalysenko>if no one knows of one, I'll just write it myself
21:00:12  <Raynos>gozala: your definition of Signal does not align with FRP
21:00:41  <gozala>I mention it explicitly it's not haskell or elm like signal
21:00:57  <gozala>lisp also has notion of signals that is different from haskells one
21:01:04  <gozala>in that it's not as pure
21:01:23  * dominictarrquit (Quit: dominictarr)
21:01:31  <Raynos>gozala: I like your hybrid
21:02:43  <gozala>Raynos: https://gist.github.com/Gozala/5314269#transformations
21:02:48  <Raynos>it aligns with the notion of being a thing that changes over time
21:03:00  <Raynos>like its a pusher that changes over time
21:03:05  <Raynos>except it doesnt change over time
21:03:08  <Raynos>the consumer changes it
21:03:32  <gozala>well it's like push stile but consumer can say
21:03:38  <Raynos>gozala: does mapped work?
21:03:43  <gozala>ok now give me rest of you and I'll decide what to do with it
21:04:08  <gozala>Raynos: well I have not actually tried :)
21:04:31  <Raynos>dominictarr has a lot of backpressure style streams in pull-stream
21:04:39  <Raynos>if you can write those with signals then your done
21:05:09  <gozala>Raynos: well this is generalisation of how reducers do back-pressure
21:05:22  <Raynos>:p
21:05:40  <Raynos>but! I dont trust a stream implementation unless I see it handle all the cases
21:05:53  <gozala>Raynos: well it does not yet
21:06:00  <Raynos>also abort
21:06:00  <gozala>I still need something for saying stop
21:06:14  <gozala>in a way pause and I never read rest is that
21:06:29  <Raynos>https://github.com/Raynos/pull-stream/blob/master/semantics.md#pull-stream-interface
21:06:33  * cianomaidinjoined
21:06:42  <Raynos>abort needs to be explicit so it can close fd
21:07:08  * fallsemo1joined
21:07:08  * fallsemoquit (Read error: Connection reset by peer)
21:07:17  <Raynos>i'd also be interested in a correct merge implementation ;)
21:07:40  <gozala>Merge is easy as long as you define what's correct implementation is
21:07:49  <gozala>the problem is there is no general correct expected behavior
21:08:51  <Raynos>:P
21:09:02  <Raynos>there should be!
21:11:56  <Raynos>gozala: https://gist.github.com/Raynos/b562da97d7275ed9153c
21:12:48  <Raynos>gozala: https://gist.github.com/Raynos/b562da97d7275ed9153c
21:12:48  <Raynos>!!!! win.
21:12:54  <Raynos>so simple.
21:14:09  <Raynos>no wait fail
21:17:50  <Raynos>https://gist.github.com/Raynos/b562da97d7275ed9153c
21:17:54  <Raynos>Ok now it works.
21:17:58  <Raynos>the first one didnt work
21:26:13  * dominictarrjoined
21:26:32  <gozala>Raynos: ok I have no idea what that does now
21:26:59  <Raynos>the same thing your one does
21:27:03  <Raynos>it just reads super weird
21:27:06  <gozala>and manual currying does not helps
21:27:42  <gozala>Raynos: I think you inverse arguments
21:27:56  <gozala>and add function call overhead at each step
21:27:58  <Raynos>i dont think i did
21:28:06  <Raynos>>:(
21:28:13  <Raynos>yeah your right
21:28:15  <Raynos>i added the func overhead
21:28:34  <Raynos>also `rest` in your example needs to return function!
21:29:53  <dominictarr>gozala: you need an example of a duplex/through
21:30:08  <gozala>Raynos: you're right
21:30:09  <gozala>https://gist.github.com/Gozala/5314269#transformations
21:30:31  <gozala>dominictarr: what's that ?
21:31:10  <dominictarr>it's like source.pipe(through).pipe(sink)
21:31:11  <Raynos>ok updated https://gist.github.com/Raynos/b562da97d7275ed9153c
21:31:39  <dominictarr>a transforming signal that just feeds into another signal
21:31:51  <Raynos>dominictarr: that's what map is
21:32:22  <Raynos>var double = map(=> x * x); sink(double(source))
21:32:22  <dominictarr>ah, I see it now
21:32:55  <dominictarr>right you just pass it the previous signal and it returns the next one
21:33:38  * wolfeidauquit (Ping timeout: 255 seconds)
21:34:03  * nicholas_quit (Remote host closed the connection)
21:35:13  <gozala>dominictarr: yeah I prefer to stick to common PL terms
21:36:14  <dominictarr>sure - this is just what raynos and I call them
21:36:30  <dominictarr>well, any generic stream that takes input and produces output
21:36:42  <dominictarr>doesn't need to be 1:1
21:37:30  <chilts>I finally figured out some stuff about streams last night :)
21:37:46  <chilts>am feeling very happy (though they still puzzle me a little)
21:37:52  <chilts>more work needed for me
21:38:15  <gozala>dominictarr: ok I tend to call that transformations
21:38:18  <Raynos>gozala: so pull streams are nice because they are (abort, next). Where as in your case you have `let [continuation, abort] = next(value)`
21:38:49  * jibayquit (Quit: Leaving)
21:38:51  * ITprojoined
21:39:50  <chilts>in streams2 they're Transform, so that probably makes sense now
21:41:09  <dominictarr>Raynos: the only problem there is that the dest needs to wait for a write before it can abort
21:45:51  <gozala>Raynos: I don't think I understand that
21:46:14  <dominictarr>but, maybe this model works best for things you don't need `abort`
21:46:23  <gozala>this proposal outlines push streams that can degrade to pull
21:46:44  <gozala>as I also pointed out I don't know how to do abort nicely yet
21:46:46  <Raynos>gozala: the consumer / writable / reader needs a way to tell the source "ABORT"
21:46:58  <substack>more ideas for browser-based unix: /dev for all the browser apis like indexdb, websockets, xhr, webrtc
21:47:19  <Raynos>im just saying that our pull-stream had two arguments and its a pain in the ass to return two values from next(value) in your map
21:47:21  <substack>to hook into bashful
21:47:23  <gozala>Raynos: Yes so reader should be able to ask to abort
21:48:23  <substack>and a mount command that can mount remote file stores including eventually consistent ones like scuttlebutt-fs
21:49:01  * wolfeidaujoined
21:50:25  * jxson_joined
21:54:13  * jxsonquit (Ping timeout: 248 seconds)
21:56:36  <juliangruber>dominictarr: how do you get a sync event with crdt? doc.on('sync', fn) never fires
21:57:00  <dominictarr>that event is on the stream now
21:57:15  <juliangruber>oh ok
21:57:17  <juliangruber>makes sense
21:57:58  <dominictarr>I did have it on the scuttlebutt - maybe there is some remants in the code for it, but it only really makes sense on the stream
21:59:47  <juliangruber>yeah, totally
22:02:56  <Raynos>substack: https://github.com/substack/hyperquest#rant
22:03:00  <Raynos>that picture is pure #win
22:07:04  * cianomaidinquit (Quit: cianomaidin)
22:07:38  * jcrugzzquit (Ping timeout: 256 seconds)
22:08:29  * AvianFluquit (Ping timeout: 256 seconds)
22:22:06  <owen1>reading about hyperquest. does it mean we should replace request with hyperquest and also shouldn't use the built-in request in node/
22:22:08  <owen1>?
22:22:54  <CoverSlide>I use node/http.request all the time
22:23:13  <CoverSlide>although usually with agent:false
22:23:25  <CoverSlide>but otherwise that suits my needs 90% of the time
22:23:37  <gozala>Raynos: https://gist.github.com/Gozala/5314269#transformations
22:23:59  <gozala>pausing can be factored out of transformation functions
22:24:13  <owen1>CoverSlide: "http requests have a default idle timeout of 2 minutes.", "There is a default connection pool of 5 requests. If you have 5 or more extant http requests, any additional requests will HANG for NO GOOD REASON"
22:25:43  <CoverSlide>right, agent: false takes care of the pooling thing
22:26:03  <CoverSlide>and 90% of the time my connections aren't idle for 2 minutes
22:27:17  <owen1>CoverSlide: do u use request?
22:27:50  <CoverSlide>i used to
22:28:01  <CoverSlide>but I just stick with plain http most of the time
22:28:48  <owen1>nice
22:28:57  <owen1>it's not adding too much code?
22:28:57  <Raynos>gozala; that code makes my head hurt
22:29:12  <Raynos>I want to see async & sync benchmarks
22:29:18  <Raynos>between that, pull-stream & streamer
22:29:19  <gozala>Raynos: well either that or you do it manually :)
22:29:40  <Raynos>or just have an extra function call :P
22:29:41  <gozala>Raynos: than go ahead and write them :)
22:30:02  <gozala>Raynos: the cost of pull is exponential
22:30:08  <Raynos>:/
22:30:12  <gozala>every transformation adds extra call
22:30:17  <gozala>on each value
22:30:30  <gozala>so longer pipeline is bigger the overhead is
22:30:33  <Raynos>so its 2 calls instead of one
22:30:41  <gozala>reducers win over arrays if arrays are big enough
22:30:45  <Raynos>so instead of O(n * m)
22:30:51  <Raynos>its O(2n * 2m)
22:30:53  <gozala>but loose if arrays are small enough
22:31:20  <gozala>because you basically end up with iteration
22:31:27  <owen1>CoverSlide: it's not adding a lot of boiler plate?
22:31:33  <gozala>but again that's not the problem
22:31:45  <gozala>problem is that some cases need pull others need push
22:32:12  <gozala>you can't represent dom events in pull style streams
22:32:24  <gozala>or you'll have to tell everyone you should keep pulling it all the time
22:32:26  * Domeni___quit (Remote host closed the connection)
22:32:29  <Raynos>agreed
22:32:40  <gozala>which is likely going to fail
22:32:46  * tanepiperquit (Ping timeout: 246 seconds)
22:32:57  <Raynos>thats why you have two streams
22:33:00  <Raynos>push & pull ;)
22:33:07  <Raynos>hybrid is a nice idea
22:33:07  * Raltquit (Ping timeout: 246 seconds)
22:33:17  <gozala>Well reducers were push by design
22:33:38  <gozala>but then I had to shoehorn pulling via concat
22:33:47  <gozala>specially for FS IO
22:34:00  <gozala>now I'm trying to generalise that idea
22:34:03  * Raltjoined
22:34:25  <gozala>I wish to make it you pay cost only when you pull
22:34:48  <gozala>but unfortunately you still have to pay for typeof(function) on each step
22:35:09  <gozala>If someone could figure way to avoid that, it would be great
22:35:23  * tanepiperjoined
22:41:52  * jxson_quit (Remote host closed the connection)
22:42:20  * jxsonjoined
22:47:52  * thl0quit (Remote host closed the connection)
22:51:50  * st_lukejoined
22:51:51  * jcrugzzjoined
22:52:09  <gozala>Raynos: https://gist.github.com/Gozala/5314269#stoping-signals
22:56:20  * fallsemo1quit (Quit: Leaving.)
23:04:37  * tanepiperquit (Ping timeout: 246 seconds)
23:09:27  * tanepiperjoined
23:13:01  <defunctzombie>anyone have some form bindings?
23:13:11  <defunctzombie>so I can access the form elements and values easier?
23:20:13  * fallsemojoined
23:20:18  <jesusabdullah>substack: you are on reddit again http://www.reddit.com/r/javascript/comments/1bor53/this_is_handsdown_my_favorite_js_library/
23:20:34  <jesusabdullah>browrstlefy is the best libary
23:25:46  <jesusabdullah>tanepiper: I forgot to follow up with you on crashing on your couch during scotlandjs. Is that going to work out?
23:33:57  <mbalho>tmcw: FYI i've been petitioning github to enable CORS on gh-pages
23:34:06  <mbalho>tmcw: if you know hubbies you should also ask for it
23:34:37  * jesusabdullahasks github to enable Coors on gh-pages
23:34:50  <jesusabdullah>dear github, I just REALLY LIKE domestic light beers!
23:41:09  * yorickquit (Read error: Connection reset by peer)
23:41:44  <dominictarr>gozala: with pull you just pull again immediately, and then it hangs until the next thing is realy
23:41:48  <dominictarr>ready
23:42:04  <dominictarr>though, I havn't used it for dom events at all yet
23:42:50  * Domeni___joined
23:43:06  <gozala>dominictarr: pull streams are good for representing things where reader has control
23:43:28  <gozala>but not in cases where values are produced regardless of readers intent
23:43:41  <gozala>Dom events are good example of that
23:43:49  <dominictarr>yes, agree
23:43:55  <gozala>user clicks around regardless weather you want him or not
23:44:00  <gozala>same with websockets
23:44:16  * CoJaBoquit (Ping timeout: 256 seconds)
23:44:18  <dominictarr>well, websockets are a middle ground
23:44:31  <dominictarr>TCP incorporates both push and pull
23:44:33  <gozala>dominictarr: depends what you use them from
23:44:45  <gozala>dominictarr: exactly!
23:44:48  <gozala>you need both IMO
23:44:49  * CoJaBojoined
23:44:52  <dominictarr>agree
23:45:00  <gozala>you should start with push and degrade to pull
23:45:08  <gozala>which is exactly what TCP does
23:45:23  <gozala>pull also has overhead associated with it
23:45:37  <dominictarr>I'm not sure if "exactly" is the right word there
23:46:24  <dominictarr>I would have said "more or less"
23:46:32  <gozala>dominictarr: ok
23:46:42  <dominictarr>anyway, there are a bunch of factors
23:46:44  <gozala>that's more precise phrasing
23:47:17  * Domeni___quit (Ping timeout: 248 seconds)
23:48:02  <dominictarr>like - being able to send an abort/close message back up the pipe is not important in DOM events
23:48:20  <dominictarr>hmm, maybe it is...
23:48:30  <dominictarr>you could have it disconnect the listener
23:48:50  <dominictarr>generally, you won't need to do that, though
23:49:30  <dominictarr>the good thing about pull though, is having lazyness/backpressure by default
23:49:48  * AvianFlujoined
23:50:02  <dominictarr>which is very handy in the case of things like level-*
23:50:35  <gozala>dominictarr: I think different use cases require different data types
23:50:41  <dominictarr>probably the best approach is just to use a different push-only streaming model for dom stuff, that really wants to be push
23:50:43  <gozala>and there is no single right choice
23:50:47  * tmcwquit (Remote host closed the connection)
23:51:08  <gozala>depending on problems you need either one or another
23:51:17  <gozala>now that being said
23:51:24  <dominictarr>you can fudge it a bit around the edges, but agree
23:51:37  <gozala>since pull has more overhead, I'm trying to design API
23:51:49  <gozala>which is push by default and can degrade to plain pull
23:51:51  <dominictarr>if your use case fits one predominate style, you should optimize for that
23:52:19  <gozala>I sort of did that adhock with reducers
23:52:27  <gozala>trying to generalise that now
23:52:32  <dominictarr>gozala: I'm happy to see it if there it's competively simple with pull-stream
23:52:35  * Domenic__quit (Ping timeout: 260 seconds)
23:52:40  <gozala>advantage is that I can reuse all the transformations
23:52:59  <gozala>dominictarr: this is draft https://gist.github.com/Gozala/5314269
23:53:38  <gozala>dominictarr: so pull streams basically are infinite / finite linked lists
23:53:46  <gozala>aka head, tail pairs
23:54:02  <dominictarr>head tail pairs?
23:54:09  <gozala>which can be explicitly or implicitly so depending on implementation
23:54:21  <gozala>dominictarr: http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-001-structure-and-interpretation-of-computer-programs-spring-2005/video-lectures/6a-streams-part-1/
23:54:44  <jesusabdullah>( head . tail) ?
23:54:49  <gozala>dominictarr: or in js if you prefer http://streamjs.org/
23:54:56  <jesusabdullah>good ole' lithp
23:55:02  <jesusabdullah>I should make jthon work sometime
23:55:53  <dominictarr>gozala: I think that is a different approach to the one I used
23:56:22  <gozala>dominictarr: well yeah you do that implicitly
23:56:30  <gozala>which is can be either good or bad
23:56:50  <gozala>but that's not really relevant
23:56:56  <dominictarr>yes, I havn't tried hard to make it pure or anything
23:57:19  <gozala>point is that stream representation is just pair of head => first item
23:57:24  <gozala>and tail => rest items
23:57:40  <gozala>so when you pull you get item in the head
23:57:49  <gozala>and you read from tail when you need to
23:58:14  * thl0joined
23:58:34  <gozala>this can be pretty hidden away
23:58:43  <gozala>as in @Raynos example
23:58:53  <gozala>but the core idea remains I think
23:59:04  <gozala>so what I wanna do with hybrid approach is
23:59:11  <gozala>have a stream that pushes values
23:59:42  <gozala>and reader can decide that it wan't to get rest as a different stream of rest items
23:59:53  <gozala>which it can read as it wants