| 00:00:00
| * ircretary | quit (Remote host closed the connection) |
| 00:00:08
| * ircretary | joined |
| 00:00:13
| * dguttman | quit (Ping timeout: 240 seconds) |
| 00:00:13
| * dguttman_ | changed nick to dguttman |
| 00:00:58
| * timoxley | quit (Quit: Computer has gone to sleep.) |
| 00:01:54
| * timoxley | joined |
| 00:03:37
| * crank | quit (Ping timeout: 256 seconds) |
| 00:05:28
| * crank | joined |
| 00:11:49
| * fallsemo | joined |
| 00:25:12
| <defunctzombie> | is there a module which will backup shits to s3? |
| 00:36:02
| * ins0mnia | quit (Ping timeout: 252 seconds) |
| 00:52:32
| * Benvie | quit (Ping timeout: 252 seconds) |
| 00:55:02
| <wolfeidau> | chrisdickinson: I was thinking more of a view into the module |
| 00:57:55
| * yorick | quit (Remote host closed the connection) |
| 00:59:35
| * Benvie | joined |
| 01:00:33
| * evbogue | joined |
| 01:01:48
| * jxson | quit (Ping timeout: 245 seconds) |
| 01:05:25
| * timoxley | quit (Quit: Computer has gone to sleep.) |
| 01:08:30
| * marcello3d | joined |
| 01:14:21
| * mikeal | quit (Quit: Leaving.) |
| 01:21:57
| * evbogue | quit |
| 01:27:58
| * evbogue | joined |
| 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
| * timoxley | joined |
| 01:47:28
| * thl0 | joined |
| 01:48:24
| * marcello3d | quit (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
| * AvianFlu | joined |
| 02:04:58
| <defunctzombie> | Raynos: some proxies set certain headers |
| 02:05:08
| * tilgovi | quit (Ping timeout: 252 seconds) |
| 02:05:53
| * mirkok | quit (Ping timeout: 255 seconds) |
| 02:06:43
| * mirkok | joined |
| 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
| * jibay | quit (Remote host closed the connection) |
| 02:16:08
| * shama | quit (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
| * timoxley | quit (Ping timeout: 252 seconds) |
| 02:20:19
| * timoxley | joined |
| 02:28:08
| * st_luke | quit (Remote host closed the connection) |
| 02:28:20
| * tilgovi | joined |
| 02:34:42
| * evbogue | quit |
| 02:54:52
| * thl0 | quit (Remote host closed the connection) |
| 03:04:14
| * dominictarr | joined |
| 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
| * nicholasf | joined |
| 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
| * nicholasf | quit (Ping timeout: 255 seconds) |
| 03:50:28
| * dominictarr | quit (Quit: dominictarr) |
| 03:58:51
| * tilgovi | quit (Ping timeout: 260 seconds) |
| 04:05:54
| <Raynos> | dominictarr: https://github.com/Raynos/pull-stream |
| 04:05:54
| * mikeal | joined |
| 04:08:45
| * mikeal | quit (Client Quit) |
| 04:11:22
| * mikeal | joined |
| 04:15:48
| * Ralt_ | joined |
| 04:16:40
| * Ralt | quit (Ping timeout: 258 seconds) |
| 04:16:40
| * Ralt_ | changed nick to Ralt |
| 04:39:19
| * gozala | joined |
| 04:57:17
| * mikeal | quit (Quit: Leaving.) |
| 04:59:17
| * douglaslassance | joined |
| 04:59:31
| * douglaslassance | changed nick to Asterokid |
| 05:02:25
| * AvianFlu | quit (Remote host closed the connection) |
| 05:04:12
| * wiwillia | joined |
| 05:04:54
| * jcrugzz | quit (Ping timeout: 264 seconds) |
| 05:18:01
| * Domenic_ | joined |
| 05:23:27
| * dguttman_ | joined |
| 05:25:08
| * dguttman | quit (Ping timeout: 245 seconds) |
| 05:25:08
| * dguttman_ | changed nick to dguttman |
| 05:32:13
| * jjjjohnnny | joined |
| 05:34:00
| * dguttman | quit (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
| * chrisdickinson | is 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
| * jjjjohnn1y | quit (Ping timeout: 276 seconds) |
| 05:38:10
| * hij1nx | quit (Ping timeout: 276 seconds) |
| 05:38:11
| * kanzure | quit (Remote host closed the connection) |
| 05:38:12
| * kanzure | joined |
| 05:38:24
| * dfgg | quit (Remote host closed the connection) |
| 05:38:31
| * dfgg | joined |
| 05:41:31
| * AvianFlu | joined |
| 05:41:51
| * AvianFlu | quit (Client Quit) |
| 05:44:54
| * dguttman | joined |
| 05:49:18
| * dguttman | quit (Ping timeout: 245 seconds) |
| 05:53:15
| * dguttman | joined |
| 05:53:32
| * dguttman | quit (Client Quit) |
| 05:55:02
| <defunctzombie> | fuck it.. ill just use a hidden iframe haha |
| 05:55:15
| * timoxley | quit (Quit: Computer has gone to sleep.) |
| 05:56:23
| * jxson | joined |
| 06:01:18
| * jxson | quit (Remote host closed the connection) |
| 06:01:27
| * wiwillia | quit (Remote host closed the connection) |
| 06:01:46
| * defunctzombie | changed nick to defunctzombie_zz |
| 06:02:02
| * wiwillia | joined |
| 06:02:16
| * wolfeidau | quit (Remote host closed the connection) |
| 06:08:53
| * ralphtheninja | quit (Ping timeout: 255 seconds) |
| 06:09:48
| * fallsemo | quit (Quit: Leaving.) |
| 06:26:39
| * mikeal | joined |
| 06:30:40
| * dguttman | joined |
| 06:34:26
| * dguttman | quit (Client Quit) |
| 06:47:06
| * mikolalysenko | quit (Ping timeout: 245 seconds) |
| 07:06:10
| * tilgovi | joined |
| 07:11:45
| * jxson | joined |
| 07:13:46
| * mikolalysenko | joined |
| 07:16:26
| * jxson | quit (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
| * mikolalysenko | quit (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
| * hij1nx | joined |
| 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> | > public-webapps@w3.org |
| 07:50:23
| * cianomaidin | joined |
| 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
| * mikolalysenko | joined |
| 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_luke | joined |
| 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
| * cianomaidin | quit (Quit: cianomaidin) |
| 08:05:58
| * mikolalysenko | quit (Ping timeout: 245 seconds) |
| 08:20:18
| <Raynos> | substack: taxi get |
| 08:29:00
| * wiwillia | quit (Ping timeout: 264 seconds) |
| 08:31:52
| * mikolalysenko | joined |
| 08:34:18
| * st_luke | quit (Remote host closed the connection) |
| 08:36:02
| * cianomaidin | joined |
| 08:42:17
| * cianomaidin | quit (Quit: cianomaidin) |
| 08:44:25
| * wolfeidau | joined |
| 08:45:29
| * mikolalysenko | quit (Ping timeout: 255 seconds) |
| 08:51:47
| * dominictarr | joined |
| 08:55:23
| * mirkok | quit (Ping timeout: 255 seconds) |
| 08:55:33
| * mirkok | joined |
| 09:09:11
| * stlsaint | quit (Ping timeout: 245 seconds) |
| 09:09:39
| * Domenic_ | quit (Ping timeout: 260 seconds) |
| 09:11:15
| * mikolalysenko | joined |
| 09:12:26
| * dominictarr | quit (Quit: dominictarr) |
| 09:21:47
| * jibay | joined |
| 09:25:18
| * mikolalysenko | quit (Ping timeout: 264 seconds) |
| 09:39:26
| * cianomaidin | joined |
| 09:41:43
| * dominictarr | joined |
| 09:45:00
| * ins0mnia | joined |
| 09:51:02
| * mikolalysenko | joined |
| 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
| * mikolalysenko | quit (Ping timeout: 246 seconds) |
| 10:08:20
| * cianomaidin | quit (Quit: cianomaidin) |
| 10:27:06
| * ins0mnia | quit (Ping timeout: 264 seconds) |
| 10:32:03
| * mikolalysenko | joined |
| 10:41:26
| * thl0 | joined |
| 10:43:47
| * mikolalysenko | quit (Ping timeout: 252 seconds) |
| 10:59:28
| * cianomaidin | joined |
| 11:10:16
| * mikolalysenko | joined |
| 11:15:33
| * cianomaidin | quit (Quit: cianomaidin) |
| 11:23:49
| * mikolalysenko | quit (Ping timeout: 248 seconds) |
| 11:27:58
| * timoxley | joined |
| 11:33:21
| * cianomaidin | joined |
| 11:44:24
| * nicholas_ | joined |
| 11:49:51
| * mikolalysenko | joined |
| 11:50:00
| * gozala | quit (Ping timeout: 264 seconds) |
| 11:51:52
| * marcello3d | joined |
| 11:55:46
| * ins0mnia | joined |
| 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
| * mikolalysenko | quit (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
| * ralphtheninja | joined |
| 12:29:23
| * mikolalysenko | joined |
| 12:42:40
| * mikolalysenko | quit (Ping timeout: 246 seconds) |
| 12:48:06
| * ins0mnia | quit (Ping timeout: 264 seconds) |
| 13:02:09
| * tmcw | joined |
| 13:10:18
| * thl0 | quit (Remote host closed the connection) |
| 13:10:54
| * mikolalysenko | joined |
| 13:16:17
| * ins0mnia | joined |
| 13:21:13
| * mikolalysenko | quit (Ping timeout: 240 seconds) |
| 13:31:38
| * fallsemo | joined |
| 13:35:44
| * thl0 | joined |
| 13:36:17
| * timoxley | quit (Quit: Computer has gone to sleep.) |
| 13:49:52
| * fallsemo | quit (Quit: Leaving.) |
| 13:50:27
| * gozala | joined |
| 13:53:03
| * mikolalysenko | joined |
| 13:53:31
| * yorick | joined |
| 13:53:32
| * yorick | quit (Changing host) |
| 13:53:32
| * yorick | joined |
| 13:58:04
| * Domenic_ | joined |
| 14:01:25
| * mikolalysenko | quit (Ping timeout: 246 seconds) |
| 14:13:58
| * AvianFlu | joined |
| 14:20:33
| * AvianFlu_ | joined |
| 14:20:33
| * AvianFlu | quit (Disconnected by services) |
| 14:20:43
| * AvianFlu_ | changed nick to AvianFlu |
| 14:22:42
| * timoxley | joined |
| 14:25:11
| * defunctzombie_zz | changed nick to defunctzombie |
| 14:26:01
| * dguttman | joined |
| 14:28:20
| * tmcw | quit (Remote host closed the connection) |
| 14:29:01
| * mikolalysenko | joined |
| 14:30:07
| * mikeal | quit (Quit: Leaving.) |
| 14:30:26
| * fallsemo | joined |
| 14:31:11
| * tmcw | joined |
| 14:40:26
| * mikolalysenko | quit (Ping timeout: 245 seconds) |
| 14:45:22
| * Domenic__ | joined |
| 14:46:00
| * Asterokid | quit (Read error: Connection timed out) |
| 14:48:33
| * dguttman_ | joined |
| 14:48:55
| * dguttman | quit (Read error: Connection reset by peer) |
| 14:48:57
| * dguttman_ | changed nick to dguttman |
| 14:51:48
| * douglaslassance | joined |
| 14:55:51
| * douglaslassance | quit (Ping timeout: 245 seconds) |
| 15:02:54
| * Domenic__ | quit (Remote host closed the connection) |
| 15:06:01
| * douglaslassance | joined |
| 15:07:12
| * mikolalysenko | joined |
| 15:14:45
| * fotoverite_ | joined |
| 15:16:01
| * mikeal | joined |
| 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
| * fotoverite | quit (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
| * mikeal | quit (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
| * Benvie | quit (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
| * dominictarr | quit (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
| * dguttman | quit (Ping timeout: 252 seconds) |
| 15:57:50
| * dguttman_ | changed nick to dguttman |
| 15:57:54
| <juliangruber> | you they are |
| 15:57:55
| * cianomaidin | quit (Quit: cianomaidin) |
| 16:00:00
| * Benvie | joined |
| 16:00:00
| * Benvie | quit (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
| * Domenic | joined |
| 16:09:26
| * Domenic | quit (Client Quit) |
| 16:09:44
| * Domenic___ | joined |
| 16:10:27
| * dguttman_ | joined |
| 16:11:23
| * dguttman | quit (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
| * jcrugzz | joined |
| 16:18:31
| * shama | joined |
| 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
| * douglaslassance | changed 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
| * yorick | quit (Read error: Connection reset by peer) |
| 16:40:17
| * dguttman | quit (Quit: dguttman) |
| 16:41:50
| * dguttman | joined |
| 17:06:27
| * stlsaint | joined |
| 17:06:27
| * stlsaint | quit (Changing host) |
| 17:06:27
| * stlsaint | joined |
| 17:06:45
| * Asterokid | quit (Quit: Leaving...) |
| 17:08:19
| * timoxley | quit (Quit: Computer has gone to sleep.) |
| 17:10:56
| * jxson | joined |
| 17:11:34
| * jxson_ | joined |
| 17:16:03
| * jxson | quit (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
| * jxson | joined |
| 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
| * timoxley | joined |
| 17:41:56
| * CryptoQuick | joined |
| 17:42:36
| * dguttman | quit (Quit: dguttman) |
| 17:43:32
| * xaq | joined |
| 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
| * jcrugzz | quit (Ping timeout: 276 seconds) |
| 18:02:33
| <mikolalysenko> | what? |
| 18:11:06
| * Domenic__ | joined |
| 18:23:27
| * xaq | quit (Remote host closed the connection) |
| 18:28:07
| * wiwillia | joined |
| 18:32:19
| * yorick | joined |
| 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
| * timoxley | quit (Quit: Computer has gone to sleep.) |
| 18:41:45
| * AvianFlu | quit (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
| * jcrugzz | joined |
| 18:58:34
| * dguttman | joined |
| 19:20:31
| * AvianFlu | joined |
| 19:20:38
| * timoxley | joined |
| 19:47:11
| * thl0 | quit (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
| * thl0 | joined |
| 19:54:30
| * xaq | joined |
| 20:04:38
| * AvianFlu | quit (Read error: Connection reset by peer) |
| 20:04:55
| * AvianFlu | joined |
| 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
| * AvianFlu | quit (Read error: Connection reset by peer) |
| 20:26:44
| * cianomaidin | joined |
| 20:26:53
| * xaq | quit (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
| * wiwillia | quit (Ping timeout: 245 seconds) |
| 20:45:30
| * cianomaidin | quit (Quit: cianomaidin) |
| 20:45:54
| <chrisdickinson> | ie9 won't, according to caniuse |
| 20:46:08
| * tmcw | quit (Remote host closed the connection) |
| 20:46:32
| <chilts> | heh, SF weather is like Wellington's ... cloudy and slightly chilly |
| 20:51:19
| * tmcw | joined |
| 20:51:55
| * cianomaidin | joined |
| 20:52:32
| * tilgovi | quit (Remote host closed the connection) |
| 20:52:44
| * cianomaidin | quit (Client Quit) |
| 20:53:35
| * dominictarr | joined |
| 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
| * cianomaidin | joined |
| 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
| * cianomaidin | quit (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
| * dominictarr | quit (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
| * cianomaidin | joined |
| 21:06:42
| <Raynos> | abort needs to be explicit so it can close fd |
| 21:07:08
| * fallsemo1 | joined |
| 21:07:08
| * fallsemo | quit (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
| * dominictarr | joined |
| 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
| * wolfeidau | quit (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
| * jibay | quit (Quit: Leaving) |
| 21:38:51
| * ITpro | joined |
| 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
| * wolfeidau | joined |
| 21:50:25
| * jxson_ | joined |
| 21:54:13
| * jxson | quit (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
| * cianomaidin | quit (Quit: cianomaidin) |
| 22:07:38
| * jcrugzz | quit (Ping timeout: 256 seconds) |
| 22:08:29
| * AvianFlu | quit (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
| * tanepiper | quit (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
| * Ralt | quit (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
| * Ralt | joined |
| 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
| * tanepiper | joined |
| 22:41:52
| * jxson_ | quit (Remote host closed the connection) |
| 22:42:20
| * jxson | joined |
| 22:47:52
| * thl0 | quit (Remote host closed the connection) |
| 22:51:50
| * st_luke | joined |
| 22:51:51
| * jcrugzz | joined |
| 22:52:09
| <gozala> | Raynos: https://gist.github.com/Gozala/5314269#stoping-signals |
| 22:56:20
| * fallsemo1 | quit (Quit: Leaving.) |
| 23:04:37
| * tanepiper | quit (Ping timeout: 246 seconds) |
| 23:09:27
| * tanepiper | joined |
| 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
| * fallsemo | joined |
| 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
| * jesusabdullah | asks github to enable Coors on gh-pages |
| 23:34:50
| <jesusabdullah> | dear github, I just REALLY LIKE domestic light beers! |
| 23:41:09
| * yorick | quit (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
| * CoJaBo | quit (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
| * CoJaBo | joined |
| 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
| * AvianFlu | joined |
| 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
| * tmcw | quit (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
| * thl0 | joined |
| 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 |