00:00:01  * ircretaryquit (Remote host closed the connection)
00:00:08  * ircretaryjoined
00:01:59  * ralphtheninjajoined
00:05:03  <Raynos>hypothetical
00:05:47  <Raynos>Imagine you had a client system with no accurate way to get Date.now() and setTimeout(cb, 1000) would run in the future at some point, maybe 500ms, maybe 5000ms
00:05:59  <Raynos>how would you represent time on such a system without polling a server
00:07:46  * ryan_stevensquit (Quit: Leaving.)
00:09:56  * st_lukejoined
00:42:03  * yorickquit (Remote host closed the connection)
00:44:25  * tilgoviquit (Remote host closed the connection)
00:50:11  <Raynos>someone needs to write a fucking good websocket abstraction
00:50:15  <Raynos>all existing ones suck
00:51:42  <jez0990>Raynos: was that comment related to your hypothetical?
00:51:51  <Raynos>no
00:51:58  <Raynos>im just debugging engine.io
00:52:01  <Raynos>and its no fucking good
00:52:31  <Raynos>https://github.com/LearnBoost/engine.io-client/issues/88
00:52:53  <Raynos>Im going to have to write my own cross browser xhr stream -.-
00:56:54  <mbalho>Raynos: DO IT
00:57:10  <mbalho>Raynos: use https://github.com/iriscouch/browser-request
00:57:18  <Raynos>FFFFFFFFFFFFFFFFFFFFFFFFFFF-----------------------------
00:57:53  <Raynos>god damn it. i might as well just rewrite the entire piece of shit
00:58:40  <Raynos>ok
00:58:42  <Raynos>well that fixed my bug
01:01:15  * mikealjoined
01:07:45  * dguttmanquit (Quit: dguttman)
01:08:44  * dominictarrjoined
01:09:49  * thatguydanjoined
01:31:28  <Raynos>mbalho: I will probably build on top of https://github.com/Raynos/xhr
01:31:31  <Raynos>which has a broken api
01:31:35  <Raynos>but has lots of bug fixes
01:31:57  <dominictarr>Raynos: what was the fix on engine.io-stream
01:32:12  <Raynos>nothing. I fixed engine.io-client
01:32:30  <Raynos>its still broken for JSONP polling
01:32:35  <Raynos>but who gives a fuck about IE
01:33:05  <dominictarr>oh right
01:33:20  <dominictarr>raynos, can I make a suggestion?
01:33:26  <Raynos>Not to rant :D
01:34:20  <dominictarr>Raynos, can I make a suggestion?
01:34:23  <Raynos>yes.
01:35:20  <dominictarr>you are too terse when you are writing english on github etc
01:35:37  <dominictarr>it comes across as rude or angry
01:35:53  <dominictarr>being terse in code is good
01:36:13  <Raynos>but I am angry.
01:36:18  <dominictarr>but in english you should take more time to carefully explain
01:36:39  <dominictarr>but you arn't like that when I talk to you in person
01:37:14  <Raynos>thats because im a dick online
01:37:42  <dominictarr>yes
01:37:52  <Raynos>noted.
01:38:14  <dominictarr>okay, well, I was just worried you where doing this by accident
01:38:28  <dominictarr>if you are doing it on purpose, that is different.
01:38:32  <Raynos>oh.
01:38:43  <Raynos>By accident or subconciously
01:38:48  <Raynos>either one.
01:39:09  <Raynos>I also use github issues as little reminders about stuff
01:39:21  <Raynos>and tend to never explain the situation in full detail
01:39:43  <Raynos>but you have a good point
01:39:45  <dominictarr>that would be fine on your own module
01:39:50  <Raynos>I should be a better community citizen
01:45:53  <jez0990>I dream that one day every module repo will have it's own virtual community space, where we can all gather and talk about how wonderful everything is and dance around the virtual campfire
01:46:04  <jez0990>that'll soon beat it out of you :D
01:48:52  <dominictarr>jez0990: agree, basically, we need an irc room attached to each project with ghchat
01:49:07  <dominictarr>when ever i meet a githubber I tell them it needs chat
01:53:31  * jibayquit (Quit: Leaving)
02:02:33  * thatguydanquit (Read error: No route to host)
02:03:00  * thatguydanjoined
02:05:26  <Raynos>that would be good
02:09:08  * defunctzombie_zzchanged nick to defunctzombie
02:11:25  <defunctzombie>dominictarr: we could build a chrome plugin that just drops a content script on the page and uses this: http://balabolka.nodejitsu.com/
02:11:55  <dominictarr>it needs to be a part of github
02:12:08  <dominictarr>because we need to communicate with the long tail
02:12:16  <dominictarr>people like us know to use IRC
02:12:25  <dominictarr>so, it's not really a problem
02:12:47  <dominictarr>for us
02:12:56  <dominictarr>but we need to get more people on board
02:30:45  * jez0990quit (Ping timeout: 276 seconds)
03:00:54  * saijanai_joined
03:00:54  * saijanai_quit (Excess Flood)
03:01:53  * saijanai_joined
03:02:20  * saijanai_quit (Client Quit)
03:09:41  * dominictarrquit (Quit: dominictarr)
03:59:56  * ryan_stevensjoined
04:29:22  * dominictarrjoined
04:42:51  <dominictarr>note to selves: http://www.coffeeshopphysics.com/articles/2011-08/26_leprechauns_and_laser_beams/
04:43:18  <dominictarr>that leprechaun trick would be a very good puzzle a programming game
04:53:06  <substack>speaking of!
04:53:22  <substack>voxel-engine is coming along pretty well
04:55:01  * defunctzombiechanged nick to defunctzombie_zz
05:01:09  <mbalho>its getting there
05:01:24  <mbalho>substack: im currently moving chunker.js into the voxel module
05:03:51  <substack>sweet
05:55:44  * dominictarrquit (Quit: dominictarr)
06:10:22  * dominictarrjoined
06:21:02  <fotoverite>Hey whats the easiest way to output a function def to a logger
06:21:12  <fotoverite>the whole function how its written ext when being passed around.
06:21:22  <fotoverite>[Function] is not helpful
06:29:35  <dominictarr>Fun.toString()
06:30:00  <dominictarr>or maybe, fun.toString().substring(0, 100)
06:30:27  <dominictarr>because the function could be very long… first hundred lines is probably enough to know that it's the right function...
06:30:39  <fotoverite>Make sense
06:34:21  <dominictarr>sorry, that is hundred chars
06:35:02  <mbalho>substack: ok just pushed new versions of voxel and voxel-engine, i think editing voxels is broken right now though
06:35:25  <mbalho>substack: BUT all the voxel creation and chunking and location logic is in the voxel module now
06:35:34  <mbalho>substack: so we can start writing tests in there
06:37:32  <substack>sweet!
06:39:01  <mbalho>substack: there are some breaking api changes: gameinstance.chunker is now gameinstance.voxels and createGame({generateVoxel: func}) is now generateVoxelChunk
06:39:10  <mbalho>(maybe others, i forget)
06:43:40  <mbalho>substack: just found http://nurgak.github.com/Cube-engine/
06:44:01  <mbalho>Cube Engine is an HTML5 3D engine based on canvas, absolutely no OpenGL and thus no 3D acceleration. This is a proof of concept and learning project, but it can be fun to some extent... as long as you have a ludicrously powerful computer.
06:44:40  <substack>wow!
06:44:50  <mbalho>yea pretty crazy
06:45:14  <substack>the collision detection is really smooth
06:45:31  <mbalho>yea we should borrow it
06:46:17  <mbalho>turning render distance up at all kills the browser
06:47:01  <dominictarr>I'm with a short distance it's good though
06:47:18  <substack>it probably renders each cube separately
06:47:26  <mbalho>yea
06:47:30  <mbalho>dominictarr: does this work in your browser? http://maxogden.github.com/voxel-engine/
06:48:19  <dominictarr>yes
06:48:26  <dominictarr>collision detection is weird though
06:48:30  <dominictarr>bumpy
06:48:57  <mbalho>yea substack wrote it
06:49:03  <mbalho>in like 10 minutes, needs work
06:49:12  <dominictarr>mind you, I have a new better computer since before
06:49:34  <dominictarr>oops, fell though the ground-
06:49:41  <mbalho>thats a feature
06:49:51  <mbalho>dominictarr: get on the multiplayer server: http://voxel.jit.su/
06:50:03  <dominictarr>have you guys seen this game http://www.lexaloffle.com/voxatron.php
06:50:08  <mbalho>yea
06:50:12  <dominictarr>really cute simple engine
06:51:09  <dominictarr>but the game is very simple compared to the pretty much limitless possibilites afforded by a voxel engine
06:51:45  <dominictarr>speaking of games
06:52:10  <dominictarr>decided that the best way to promote anarchy is to teach many people to programme
06:52:13  <substack>dominictarr: a better computer you say!
06:52:31  <dominictarr>well, the hardware is better
06:52:35  <dominictarr>macbook air
06:52:47  <dominictarr>not really impressed by the os
06:52:57  <substack>software is one of the domains where anarchy works the best
06:53:19  <fotoverite>And it chrased firefox
06:53:33  <mbalho>fotoverite: voxel.jit.su?
06:53:33  <substack>anyhow a voxel-based wizard game would be really great
06:53:38  <dominictarr>it learns you to think of everything as a system
06:53:39  <mbalho>fotoverite: what version of firefox?
06:53:39  <fotoverite>yes
06:53:44  <fotoverite>aurora
06:53:49  <mbalho>is that like chromium
06:53:52  <dominictarr>and to realize that most systems just suck
06:54:01  <dominictarr>and that you can create your own systems
06:54:17  <fotoverite>O wow that's so cool!
06:54:24  <fotoverite>Minecraft in the browser in 10 inutes
06:54:38  <dominictarr>and that you shouldn't really put up with other people's crappy systems, when you can create your own
06:54:55  <substack>dominictarr: and once this game uses scuttlebutt and leveldb it'll make a pretty good demo for writing a distributed application
06:55:08  <dominictarr>oh, cool.
06:55:11  <substack>fotoverite: that's the idea!
06:55:36  <dominictarr>what are tho controls?
06:55:46  <dominictarr>I'm deleting blocks, how to add
06:55:46  <substack>x to toggle create/destroy
06:55:47  <dominictarr>?
06:57:14  <dominictarr>awesome, I made a bridge
06:58:27  * morphRxjoined
06:58:42  <mbalho>lol
06:58:44  <mbalho>horse party
06:58:54  <mbalho>cant wait till the game doesnt suck
06:59:22  <substack>I encased somebody in carbonite
06:59:26  <mbalho>lol
06:59:48  <st_luke>holy shit i just watched toe surgery on youtube
06:59:49  <st_luke>oh man
07:01:04  <dominictarr>substack: does shoe pause strictly?
07:01:11  <jjjjohnnny>am i a horse?
07:01:30  <dominictarr>JJJOHNNY IS HORSE.JS
07:01:32  <substack>jjjjohnnny: affirmative
07:01:38  <mbalho>oo logging back in
07:01:50  <mbalho>everyone refresh!
07:01:51  <substack>dominictarr: yes it buffers
07:01:54  <mbalho>gotta reset the world
07:01:57  <dominictarr>great
07:02:03  <substack>THE WORLD IS WRONG
07:02:48  <mbalho>we should write a breakout implementation in voxel-engine and submit it to http://city41.github.com/breakouts/
07:04:51  <jjjjohnnny>this is what is was like in the dawn of time before there were mirrors
07:06:27  <jjjjohnnny>im so glad to be a silver horse praise ra
07:06:38  <jjjjohnnny>WAIT WHERE IS RA?
07:10:51  <jjjjohnnny>or were the other silver horses lying to me?
07:11:25  <jjjjohnnny>mockinghorses
07:14:14  * defunctzombie_zzchanged nick to defunctzombie
07:22:50  <mbalho>jjjjohnnny: dey only humans if dey movin
07:23:08  <mbalho>substack: the guy who wrote the meshing code we are using made this repo the other day but i havent determined if it is useful or not https://github.com/mikolalysenko/rle-voxels
07:23:54  * st_lukequit (Remote host closed the connection)
07:26:57  <dominictarr>heh, run length encoding… like gif
07:27:07  <substack>mbalho: awesome to see this: prepping for publishing to npm [mikolalysenko]
07:28:00  <mbalho>it is there https://npmjs.org/package/rle-voxels
07:32:05  * Madarsquit (Remote host closed the connection)
07:38:20  * morphRxpart ("Leaving...")
07:39:44  <jjjjohnnny>lol "teaches sophisticated SaaS and Agile skills, such as working with legacy code..."
07:40:57  * AvianFluquit (Remote host closed the connection)
07:41:50  * st_lukejoined
07:44:07  * st_lukequit (Remote host closed the connection)
07:46:55  <mbalho>substack: http://www.reddit.com/r/gamedev/comments/15mbjg/the_big_list_of_block_engines_resources_continued/
07:47:21  <mbalho>substack: actually this link is better http://www.reddit.com/r/gamedev/wiki/block_engines
07:47:25  <dominictarr>substack: shoe doesn't buffer, it doesn't even have .pause()
07:47:31  <mbalho>SO MUCH C++ AND JAVA
07:50:05  * st_lukejoined
07:52:29  <dominictarr>should make a hexagonal block world
07:52:33  <dominictarr>it's more node.js
08:02:44  * defunctzombiechanged nick to defunctzombie_zz
08:03:38  <guybrush_>dominictarr: with marching cubes you come close to it
08:03:44  <substack>dominictarr: it doesn't have .pause() but it buffers the initial messages
08:03:56  <substack>note the var buffer = [] in browser.js
08:03:57  <dominictarr>… until you pipe?
08:04:12  <substack>it buffers until the connection is established
08:04:56  <dominictarr>right. that is also something a stream must do
08:10:48  * ryan_stevensquit (Quit: Leaving.)
08:14:39  <dominictarr>hmm, we need a way to make websocket middleware, not just this attach(server) bullshit
08:19:01  <substack>no
08:19:13  <substack>we actually need a nice way to pass (req,res) pairs to websocket modules
08:19:33  * mikealquit (Quit: Leaving.)
08:19:38  <substack>node cores makes this difficult because websocket requests go through the 'upgrade' event
08:19:45  <substack>*node core
08:27:44  * mikealjoined
08:34:22  <dominictarr>yes, that is what I meant to say
08:42:08  * AndChat648704quit (Ping timeout: 252 seconds)
09:02:04  <st_luke>Picard is the best
09:12:37  * defunctzombie_zzchanged nick to defunctzombie
09:20:28  * dominictarrquit (Quit: dominictarr)
09:22:26  * defunctzombiechanged nick to defunctzombie_zz
09:23:00  * thatguydanquit (Ping timeout: 248 seconds)
09:23:08  * jez0990_joined
09:33:16  * gwenbelljoined
09:35:20  * jez0990_quit (Ping timeout: 255 seconds)
10:04:05  <substack>mbalho: https://github.com/maxogden/voxel/pull/1
10:07:47  <substack>it would be nice if voxel(function (x, y, z) {}) worked
10:08:31  * jibayjoined
10:09:06  <substack>right now it goes through this weird chunker thing
10:18:04  * devaholicquit (Quit: Leaving)
10:24:40  <jjjjohnnny>is voxel a pixel filling engine?
10:25:37  <jjjjohnnny>what is a voxel
10:34:06  * dominictarrjoined
10:51:19  <substack>a voxel is like a 3-dimensional pixel display thing
10:51:39  <substack>instead of 2d pixels there are little 3d boxes
10:52:52  <jjjjohnnny>i cloned the voxel engine repo and ran the demo, but no blocks or horses just blue skies far ever
10:54:56  <substack>jjjjohnnny: try the voxel-server repo
10:57:07  <jjjjohnnny>thats it
10:59:45  <jjjjohnnny>window.horseGeometry
11:03:41  <dominictarr>they don't HAVE to be boxes. you could make them little sprites, or something
11:04:09  <jjjjohnnny>this.voxels = voxel(this)
11:04:29  * thatguydanjoined
11:17:29  * jez0990joined
11:17:29  * jez0990quit (Changing host)
11:17:29  * jez0990joined
11:25:00  * st_lukequit (Remote host closed the connection)
12:17:38  * thatguydanquit (Remote host closed the connection)
12:17:55  * thatguydanjoined
12:34:35  * thatguydan_joined
12:37:54  * thatguydanquit (Ping timeout: 240 seconds)
12:37:55  * thatguydan_changed nick to thatguydan
13:07:22  <dominictarr>jesusabdullah: hey will you take a pullrequest for ecstatic to add a cli version?
13:07:55  <dominictarr>I want to go `ecstatic --port 8080` and have it just start hosting the current dir`
13:12:36  * owen1quit (Ping timeout: 276 seconds)
13:17:47  * owen1joined
13:19:14  <dominictarr>pull request coming anyway
13:21:24  <dominictarr>hmm. thought for a second it might be cool to have an option to generate index.html automatically...
13:21:43  <dominictarr>but then realized it would be much better to have a tool that generated that statically
13:28:05  <substack>there's http-server
13:33:39  <guybrush_>also serve https://github.com/visionmedia/serve
13:43:14  <dominictarr>I want to use ecstatic, because it's what I use as middleware, so it's gonna be just one set of docs.
13:50:37  * _sorensenjoined
13:50:50  * _sorensenquit (Client Quit)
13:53:22  <dominictarr>jesusabdullah: https://github.com/jesusabdullah/node-ecstatic/pull/58
13:55:45  * _sorensenjoined
13:57:21  * _sorensenquit (Client Quit)
13:58:06  * _sorensenjoined
14:12:12  <dominictarr>substack: I think I'm gonna need to run browserify on the server.
14:12:29  <dominictarr>to generate code that can run safely inside a new context
14:12:47  <dominictarr>with some things crippled, net, and fs
14:12:56  <dominictarr>but to otherwise allow any modules
14:31:24  * _sorensenquit (Quit: Bye!)
14:32:18  <isaacs>dominictarr: https://twitter.com/domenic/status/288291173888565248
14:32:27  <isaacs>dominictarr: i don't get that. what's "zero specs" mean?
14:32:49  <isaacs>dominictarr: also, st does this already
14:32:50  <dominictarr>he means a testcase that has no tests
14:33:09  <dominictarr>so, like echo "" > test.js
14:33:16  <isaacs>dominictarr: `st` serves the current dir on 1337. `st -h` shows the options.
14:33:22  <dominictarr>is a valid js program, but not a valid test.
14:33:27  <isaacs>oh, i see.
14:33:43  <isaacs>well... if your test runner is "zero exit = success" then it IS a valid test.
14:34:21  <dominictarr>well, "valid" isn't maybe the right word, "useful" would have been better.
14:37:41  <isaacs>sure
14:37:45  <isaacs>that makes sense, i suppose
14:37:52  <isaacs>i'll probably not change tap for that though
14:38:13  <isaacs>the global runner could emit a failure if no tests are run, though
14:38:20  <isaacs>er, global harness
14:41:28  <isaacs>ircretary: tell bnoordhuis to ping me when he gets online
14:41:29  <ircretary>isaacs: I'll be sure to tell bnoordhuis
14:50:57  * dguttmanjoined
15:19:39  * yorickjoined
15:19:39  * yorickquit (Changing host)
15:19:39  * yorickjoined
15:25:36  * dguttmanquit (Quit: dguttman)
15:31:58  * AvianFlujoined
15:39:46  * dguttmanjoined
15:43:09  <dominictarr>http://www.youtube.com/watch?v=112d45b03hM&playnext=1&list=PL271659286868D2AA&feature=results_video
15:43:20  <dominictarr>peer to peer communism vs the client-server state
15:51:39  <guybrush_>dominictarr: sweet, thx for sharing
15:52:00  <dominictarr>I havn't watched it yet, but the title seems promising
15:52:09  <guybrush_>yes thats what i thought :D
16:11:28  * dominictarrquit (Quit: dominictarr)
16:12:16  <guybrush_>woooaah i would like to sit in this talk and ask questions
16:15:38  * defunctzombie_zzchanged nick to defunctzombie
16:34:03  <guybrush_>really the thing is we live in a world where everyone depends on the moneys, just cant think of any way where people do things just for the greater "social" good
16:34:30  <guybrush_>sure there are some who can live from doing that, but most dont
16:35:21  <guybrush_>its kind of sad
16:36:38  <guybrush_>its incredible that opensource got that far in such a world
16:48:42  <jez0990>that was an awesome lecture
16:53:12  * mikealquit (Quit: Leaving.)
16:55:40  * dominictarrjoined
17:13:30  * defunctzombiechanged nick to defunctzombie_zz
17:14:37  * ryan_stevensjoined
17:16:47  * dguttmanquit (Quit: dguttman)
17:19:11  * dominictarrquit (Quit: dominictarr)
17:19:21  <ehd>anyone hacked on a LEAP motion device yet?
17:22:14  * mikealjoined
17:24:03  * ryan_stevensquit (Quit: Leaving.)
17:27:37  * heathquit (Quit: http://quassel-irc.org - Chat comfortably. Anywhere.)
17:34:18  * ITproquit (Ping timeout: 272 seconds)
17:34:33  * ITprojoined
17:37:27  * thatguydanquit (Quit: thatguydan)
17:47:56  * dguttmanjoined
17:52:43  * ryan_stevensjoined
17:53:36  * ITproquit (Ping timeout: 245 seconds)
17:54:13  * ITprojoined
18:04:36  * heathjoined
18:08:15  * defunctzombie_zzchanged nick to defunctzombie
18:13:24  * tphummeljoined
18:14:29  * ryan_stevensquit (Quit: Leaving.)
18:27:14  <defunctzombie>isaacs: is there a way to make npm install to --production by default?
18:27:20  <defunctzombie>something in an npm config file maybe?
18:27:45  <isaacs>defunctzombie: npm config set production true
18:27:49  <defunctzombie>:D
18:27:50  <isaacs>defunctzombie: npm help config
18:27:54  <defunctzombie>gracias
18:32:54  * heathquit (Changing host)
18:32:54  * heathjoined
18:39:28  * ryan_stevensjoined
18:56:22  * Dspriggsjoined
19:22:30  <Raynos>https://twitter.com/Raynos2/status/288364981207056384
19:38:38  * defunctzombiechanged nick to defunctzombie_zz
19:39:35  * ryan_stevensquit (Quit: Leaving.)
19:44:40  * ryan_stevensjoined
20:03:02  * jez0990quit (Ping timeout: 252 seconds)
20:19:58  * ryan_stevensquit (Quit: Leaving.)
20:30:28  * AndChat648704joined
20:30:33  * ryan_stevensjoined
20:32:39  * gwenbellquit (Ping timeout: 276 seconds)
20:45:24  * ryan_stevensquit (Quit: Leaving.)
20:48:30  * thatguydanjoined
20:58:45  * ryan_stevensjoined
21:03:42  * defunctzombie_zzchanged nick to defunctzombie
21:06:00  * gwenbelljoined
21:13:59  * gwenbellquit (Ping timeout: 260 seconds)
21:19:23  * thatguydanquit (Remote host closed the connection)
21:19:35  * thatguydanjoined
21:19:44  <defunctzombie>substack: http://questionablecontent.net/view.php?comic=2357
21:27:09  * dominictarrjoined
21:27:20  * nk109quit (Quit: Computer has gone to sleep.)
21:34:35  <mbalho>i have a theory that substack synchronizes his sleeping schedule to whatever time zone dominictarr is currently in
21:35:03  <dominictarr>nonsense!
21:35:17  <dominictarr>we come to a compromize that works for both of us!
21:36:09  <mbalho>lol
21:46:46  * thatguydanquit (Quit: thatguydan)
21:47:46  <defunctzombie>hahah
21:55:42  <hij1nx>the dominictarr
21:56:06  <dominictarr>hij1nx: whats up?
21:56:35  <hij1nx>i cant start the wiki page on leveldb
21:56:40  <hij1nx>i would if i could
21:57:22  <hij1nx>seems a shame to let that idea go stale, its a good one to have a catalog of all the interesting things that are going on around leveldb.
21:57:26  <mbalho>wikipedia?
21:57:38  <hij1nx>mbalho: no, github wiki
21:57:40  <mbalho>ah
21:57:45  <mbalho>there should be leveldb.com for fucks sake
21:58:01  <mbalho>who are you people! http://www.almdesignstudio.com/indexhibit/
21:58:11  <hij1nx>dominictarr: im going to release a blog post on friday and would love to have that up.
21:58:24  <mbalho>level-db.com is available
21:58:32  <hij1nx>mbalho: grab it!
21:59:13  <mbalho>i have too many domains already
21:59:16  <mbalho>tryign to cut back
22:00:18  <dominictarr>hij1nx: https://github.com/rvagg/node-levelup/wiki/modules-&-plugins
22:01:20  <hij1nx>i just got leveldb.org
22:11:30  * ryan_stevensquit (Quit: Leaving.)
22:12:07  <mbalho>hij1nx: nice
22:16:03  <rvagg>hij1nx: shal we use it as a CNAME for a gh-pages branch on levelup since we all have access there (you too now)?
22:18:55  * ryan_stevensjoined
22:19:20  <CoverSlide>leveldb-for-cats.com
22:22:53  <mbalho>hahah
22:22:58  <mbalho>i have for-cats.com
22:23:01  <mbalho>so that we can do subdomains
22:23:28  * thatguydanjoined
22:33:36  <defunctzombie>wow
22:33:56  <defunctzombie>max.. I think you have a serious condition
22:36:31  <mbalho>you leave my cats out of this!
22:41:31  <Raynos>dominictarr: Is it weird to use crdt but to not replicate it anywhere?
22:41:43  <Raynos>I think I want to use it for purely having a place to manage my state in my front end app.
22:42:04  <dominictarr>sure, but that doesn't mean you shouldn't use it!
22:42:26  <Raynos>im curious whether there's a better alternative
22:42:36  <dominictarr>I had always intended crdt to be as easy to use as Model in backbone
22:42:36  <Raynos>other wise ill just use crdt
22:43:02  <dominictarr>well, it will probably work fine
22:43:22  <dominictarr>maybe you can replicate it to another tab or something
22:43:32  <dominictarr>if you really want to use all the features
22:48:58  * st_lukejoined
23:00:19  * AndChat648704quit (Ping timeout: 248 seconds)
23:03:17  * AndChat|648704joined
23:11:33  * Raynos_joined
23:11:47  <Raynos_>dominictarr: what's your opinion on https://github.com/dominictarr/crdt/issues/12 ?
23:11:57  <Raynos_>I feel like I want more complex sets based on filters on a document
23:12:17  <Raynos_>Also I just realized I can simplify my code a ton by replicating crdt over pubnub instead of custom bullshit message exchange
23:12:21  <Raynos_>which is big win
23:12:53  <dominictarr>YES
23:13:04  <dominictarr>oh, sorry ambigious
23:13:11  <dominictarr>yes to big win
23:13:35  <dominictarr>sounds like you want a filter on your set?
23:13:54  <Raynos_>Yeah I want a filter on my set
23:14:05  <Raynos_>Or wait
23:14:10  <Raynos_>I can just duplicate information
23:14:12  <Raynos_>Yeah that would work
23:14:19  <Raynos_>Got IT
23:14:58  * isaacschanged nick to __proto__
23:15:01  <Raynos_>Nope still need a better filter
23:15:05  <Raynos_>isaacs: #winning
23:15:12  <Raynos_>__proto__: do not crash please
23:17:33  * Dspriggsquit (Ping timeout: 245 seconds)
23:19:03  <dominictarr>sets are indexed, kinda, so it knows that this is a set of type=public-message or location=my-town
23:19:38  * Raynos_quit (Ping timeout: 245 seconds)
23:19:57  * yorickquit (Remote host closed the connection)
23:23:04  * Raynos_joined
23:23:11  <Raynos>isaacs: </3
23:23:13  <Raynos_>dominictarr: with a crdt.Seq
23:23:26  <Raynos_>if I doc.add({ ... }) without a _sort property what happens?
23:23:45  <dominictarr>it adds one for you
23:23:58  <dominictarr>or errors, i forget which right now
23:25:40  <dominictarr>Raynos_: the filter would be easiest to implement as either a filter on top of set location=mytown, and the you filter to public messages
23:26:02  <dominictarr>or add a combined prop… publicMessageLocation
23:26:03  * ryan_stevensquit (Read error: Connection reset by peer)
23:26:12  <Raynos_>dominictarr: I went for combined prop
23:26:27  <Raynos_>I'm curious whether there's value in `crdt.Set(doc, filterFunction)`
23:26:34  * gwenbelljoined
23:26:36  <dominictarr>so… if there was a computed property feature that would be easy
23:27:26  <isaacs>Raynos: </3?
23:27:32  * isaacscries
23:27:37  <dominictarr>Raynos_: that does sound simple… but you would have to call filterFunction for every change for every set
23:27:47  <Raynos_>isaacs: your __proto__ broke my web irc client
23:27:53  * ryan_stevensjoined
23:28:08  <Raynos_>dominictarr: right now you have to check key / value for every change for every set
23:28:45  <dominictarr>correct
23:29:02  <Raynos_>dominictarr: running a function instead is only slightly more overhead
23:29:07  <dominictarr>hmm, I guess it would be the same then.
23:29:14  <isaacs>Raynos_: hahaha
23:29:17  <isaacs>Raynos_: whoops
23:29:22  <dominictarr>it would just be crdt.Set(filter)
23:29:36  <mbalho>hahaha
23:29:40  <Raynos_>well crdt.Set(doc, filter) or doc.createSet(filter)
23:30:05  <dominictarr>ah, yes
23:30:11  <isaacs>Raynos_: i tried to set it to document.write('<script>alert(/xss/)</script>') but that's not a valid nick
23:31:06  <isaacs>Raynos_: so, i've been thinking about stream.push(data)
23:31:23  <isaacs>Raynos_: the problem is that there's no way to provide backpressure there.
23:31:31  <isaacs>Raynos_: unless we have push() return true/false maybe
23:31:42  <dominictarr>sounds familiar
23:31:54  <Raynos_>isaacs: well i was thinking about it from a larger point of view
23:32:04  <dominictarr>what does push do?
23:32:10  <Raynos_>which is that what I'm doing with stream.push(data) is turning a push style stream source into a Readable pull stream
23:32:19  <Raynos_>dominictarr: similar to through.queue
23:32:24  <dominictarr>right
23:32:33  <Raynos_>isaacs: how do you turn a push source into a back pressure enabled pull stream
23:33:05  <dominictarr>this works better with a classic stream because the dest gives the source an explicit pause state
23:33:24  <dominictarr>so when you queue/push you know if you are paused or not
23:33:25  <Raynos_>isaacs: feels like push / queue / whatever should return true/false based on "are we above high watermark"
23:33:40  <isaacs>Raynos_: right. so, how do you know when you'er below the watermark again?
23:33:45  <isaacs>Raynos_: that's the tricky bit.
23:33:54  <isaacs>returning true/fasle based on watermark is not hard.
23:33:58  <Raynos_>isaacs: _read gets called when yoru below low
23:34:01  <isaacs>but you don't get a drain event
23:34:08  <isaacs>so you have to hook into _read
23:34:15  <dominictarr>but in this case its easy to just check push.length or something
23:34:16  <Raynos_>yep
23:34:41  <Raynos_>isaacs: the bigger problem is its bloody hard to turn a push-style stream into a pull-style stream with backpressure
23:34:47  <isaacs>myStream._read = function(n, cb) { source.resume(); }; source.on('data', function(c) { if (!myStream.push(c)) source.pause(); })
23:35:12  <isaacs>Raynos_: so that'd be it, right? ^
23:35:16  <Raynos_>isaacs: but then making source an old style stream feels silly
23:35:38  <dominictarr>… yeah, that would work in classic streams by passing the pause up, and then the source's source stops feeding the buffering push stream
23:35:56  <Raynos_>isaacs: you also need to reimplement pause/resume in your source which means we have the same problem
23:36:02  <Raynos_>as we have in old streams
23:36:07  <Raynos_>pause/resume is hard and we get it wrong
23:36:17  <Raynos_>I think the answer is never deal with push sources
23:36:18  <Raynos_>:D
23:37:34  <isaacs>Raynos_: well, right.
23:37:56  <isaacs>Raynos_: why do you have a thing that's throwing data at you forcibly and cannot be paused? that's not a stream, that's an event emitter. and kind of a dick.
23:39:15  <Raynos_>isaacs: because the pubnub subscribe client has no back pressure
23:39:29  <isaacs>Raynos_: right.
23:39:31  <Raynos_>because it uses HTTP long polling
23:39:41  <isaacs>Raynos_: so, what do you want to do when the stream isn't being consumed?
23:39:42  <Raynos_>and it doesn't even consider that I want it to slow down
23:39:57  <isaacs>you can either ignore the pause message and just shove it all into the buffer anyway.
23:39:58  <Raynos_>same with engine.io
23:39:58  <dominictarr>don't use pubnub
23:40:08  <Raynos_>and sockJS
23:40:13  <Raynos_>they are websocket emulations and dont do backpressure
23:40:17  <isaacs>Raynos_: or you can just keep a "paused" state and drop data when you're paused.
23:40:18  <Raynos_>you can implement backpressure on top of it
23:40:24  <Raynos_>but the data has to be buffered somewhere
23:40:37  <Raynos_>you can drop data but then you just turned TCP into UDP
23:40:48  <Raynos_>because if you drop data your application needs resending logic
23:40:54  <Raynos_>or your application needs to not give a shit about missed packages
23:41:10  <isaacs>Raynos_: var paused = false; src.on('data', function(c) { paused = paused || !stream.push(c) }); stream._read = function() { paused = false }
23:41:20  <Raynos_>i dont want to lose packages
23:41:29  <isaacs>Raynos_: if you don't have backpressure, you must have data loss.
23:41:34  <isaacs>Raynos_: this is not optional.
23:41:48  <isaacs>Raynos_: anything else is too brittle.
23:41:55  * defunctzombieloves data loss
23:41:56  <Raynos_>well there is data
23:41:57  <Raynos_>somewhere
23:42:04  <isaacs>Raynos_: you can have your own buffer, and some configurable limit, but in reality, you'll always hit that limit *eventually*(
23:42:09  <isaacs>the question is what you do then
23:42:11  <Raynos_>either someone buffers it
23:42:14  <Raynos_>or the data gets dropped
23:42:17  <isaacs>right
23:42:25  <isaacs>and this decision must be made at every level.
23:42:26  <Raynos_>I havnt really thought or dealt with situations
23:42:31  <isaacs>either you stop reading, or you lose data.
23:42:32  <Raynos_>where your network is saturated at the
23:42:42  <Raynos_>bandwidth layer
23:43:01  <isaacs>it's worth not thinking about anything *except* edge cases until you have traced the edges of your problem. if you just handle the edge cases elegantly, then usually the juicy middle Just Works.
23:43:02  <Raynos_>well lets say you stream live video over TCP
23:43:03  <defunctzombie>oh man.. Raynos_ that is the most fun thing to deal with :)
23:43:08  <defunctzombie>data just goes away
23:43:11  <isaacs>Raynos_: right
23:43:12  <Raynos_>the other end doesn't want to buffer the video
23:43:17  <isaacs>live video is a great example.
23:43:21  <Raynos_>but my end is like "TOO MUCH VIDEO. GO AWAY"
23:43:30  <Raynos_>and the other end is like "TAKE MY VIDEO OR I DROP IT"
23:43:58  <Raynos_>the problem I have is someone needs to buffer it or data dissappears
23:44:00  <isaacs>Raynos_: so, when you do that, you have to drop every other frame or something, and then also send a message to the server to be like "USE SMALLER FRAMES! MUST HAS CRAPPIER VIDEO!"
23:44:10  <Raynos_>Oh interesting
23:44:18  <Raynos_>your just reduce information density
23:44:21  <isaacs>Raynos_: that's what hulu netflix et al do
23:44:33  <isaacs>if your computer can't handle the frame rate, you'll get lower density data.
23:44:53  <Raynos_>the problem is how do I implement back pressure for things that dont have clean back pressure
23:44:56  <Raynos_>like browser IO APIs
23:44:57  <isaacs>some time try watching a movie on netflix with a really fast internet connection, and start some big `make -j32` on a fresh node checkout
23:45:03  <isaacs>you'll see the video get noticeably crappier
23:45:20  <isaacs>of course, they also have some backpressure there.
23:45:22  <isaacs>because it's not a live stream
23:46:07  <isaacs>Raynos_: you have three options: 1. backpressure 2. drop chunks that you're not able to take 3. implement your own intelligent bufering mechanism
23:46:16  <isaacs>Raynos_: i'd suggest that you stay away from #3
23:46:28  <isaacs>Raynos_: if you want smarter buffering, then that should be a separate module.
23:46:53  <isaacs>Raynos_: and if you're streaming live video, just accept that you probably can't do that with the same generic streaming modules you use for other stuff, because it's so app specific
23:47:31  <Raynos_>ok
23:47:34  <Raynos_>So how do I 1. ?
23:48:03  <Raynos_>and what does it mean to do 2. ?
23:48:12  <Raynos_>I can't imagine having so much data that I cant render / handle it.
23:48:17  <Raynos_>unless it's video or something
23:48:21  * defunctzombiechanged nick to defunctzombie_zz
23:48:43  * dominictarrquit (Quit: dominictarr)
23:48:50  <Raynos_>isaacs: the answer to how do I do 1. should be Readable has a nice API to handle backpressure from push inputs
23:49:19  <isaacs>Raynos_: 1 means "make the thing yor'e consuming from handle backpressure properly"
23:49:21  * ryanseddon_changed nick to ryanseddon
23:49:25  <isaacs>Raynos_: ie, don't read from a pub/sub
23:49:32  <isaacs>Raynos_: read from a stream
23:50:28  <isaacs>Raynos_: 2 is "if data comes in and you're in a 'paused' state, then just drop it"
23:50:43  <isaacs>Raynos_: var paused = false; src.on('data', function(c) { paused = paused || !stream.push(c) }); stream._read = function() { paused = false }
23:50:51  <Raynos_>your only in a paused state if the high watermark for buffering is hit ?
23:51:12  <isaacs>Raynos_: right, this is assuming a "push(chunk)" method is added that returns false when it's at the high water mark
23:51:13  <Raynos_>isaacs: what about making stream.push / stream.queue just drop data if the high watermark is hit AND return true
23:51:19  <isaacs>Raynos_: no.
23:51:26  <isaacs>Raynos_: it should work like writable.write(chunk)
23:51:39  <Raynos_>why.
23:51:39  <isaacs>Raynos_: ie, return true/false, but still keep it buffered in memory
23:51:46  <isaacs>dropping data is surprising.
23:51:48  <Raynos_>whats the point of a high watermark
23:51:51  <Raynos_>if its supervisory
23:51:53  <isaacs>Raynos_: it's advisory
23:52:01  <isaacs>it's up to you to respect it
23:52:12  <Raynos_>the same with old streams pause() :D
23:52:24  <Raynos_>"yeah we have pause() but no-one respects it"
23:52:30  <isaacs>Raynos_: well, no, the same with write(), then and now
23:52:37  <isaacs>Raynos_: you can keep writing when write() returns false.
23:52:42  <isaacs>you can write() until you're out of memory
23:52:58  <Raynos_>I feel that push should drop
23:53:14  <isaacs>w = new Writable; w._write = function() {}; for(;;)w.write(new Buffer(1024))
23:53:19  <Raynos_>because that's the default logic I'm going to want
23:53:22  <Raynos_>and I don't want to implement it.
23:53:26  <Raynos_>for ever ysource.
23:54:47  * ITproquit (Ping timeout: 252 seconds)
23:55:21  * ITprojoined
23:58:38  <isaacs>Raynos_: module.exports = function dropper(src, stream) { var paused = false; src.on('data', function(c) { paused = paused || !stream.push(c) }); stream._read = function() { paused = false } }
23:58:54  <isaacs>Raynos_: too bad you can't npm install an irc pmsg ;)