00:00:16  <txdv_>and a wrong type would fuck up everything
00:00:36  <txdv_>what dynamic language has function templates
00:01:48  <bnoordhuis>piscisaureus_, txdv_: what i like about lua (and by extension luvit) is that lua is the simplest, least intrusive, non-warty language i know
00:02:04  <bnoordhuis>it's clean, it's dead simple, even more so than c
00:02:23  <bnoordhuis>having to type i = i + 1 all the time is kind of annoying but not greatly so
00:02:41  <bnoordhuis>i guess the one thing that sucks is luarocks, the lua package manager
00:02:56  <txdv_>lua has no i++?
00:02:59  <bnoordhuis>no
00:03:03  <txdv_>just like ruby
00:03:11  <txdv_>why not lisp
00:03:16  <txdv_>lisp has the simplest api ever
00:03:17  <bnoordhuis>i didn't know that. goes to show how well i know ruby :/
00:03:30  <bnoordhuis>actually... lisp is pretty annoying and verbose
00:03:36  <bnoordhuis>it has good things and bad things
00:03:51  <txdv_>well not everyone has to know ruby
00:04:04  <txdv_>i know ruby because it was my first dynamic language I leaned
00:04:04  <bnoordhuis>no. but i'm doing a talk at a ruby conf tomorrow
00:04:17  <piscisaureus_>ruby is no country for real men
00:04:25  <txdv_>ruby is a bitch
00:04:28  <bnoordhuis>i'll be sure to tell em that :)
00:04:29  <txdv_>you can make her do whatever you want
00:05:07  <txdv_>when you code ruby you don't think how to code stuff, you think about how to create a mini dsl around your lib
00:07:04  <txdv_>what I liked the most about ruby that it is very easy to execute stuff in the shell
00:07:31  <txdv_>shell.js is integrated in ruby
00:08:41  <txdv_>bnoordhuis: what are you going to talk about?
00:08:59  <bnoordhuis>txdv_: what node is, how async i/o works, how awesome npm is
00:09:17  <bnoordhuis>i'm going to do some chat app live coding
00:10:16  <txdv_>there is libuv binding for ruby
00:10:44  <txdv_>the good thing about node/npm is that all apis are build around libuv
00:10:46  <bnoordhuis>yeah, i know, the guy that did it sent some patches
00:10:48  <txdv_>because you can't do io anyway different
00:10:52  <bnoordhuis>here's the talk btw https://github.com/bnoordhuis/slides/tree/oct12
00:11:10  <txdv_>it says move along
00:11:41  <bnoordhuis>txdv_: you need the oct12 branch
00:12:08  <bnoordhuis>and the 'move along' is just for the uninitiated
00:12:26  <txdv_>if I would have to describe to a rubists what node.js is in one sentence
00:12:32  <txdv_>it would go something like this:
00:13:04  <txdv_>Imagine you would have eventmachine and it would be the only way to do IO, so all existing apis are async based
00:14:19  <txdv_>maybe i should do a talk about libuv and libuvsharp in the next fosdem
00:15:21  <txdv_>how did you make these slides?
00:15:51  <bnoordhuis>txdv_: with reveal.js
00:15:58  <bnoordhuis>and vim
00:16:50  <bnoordhuis>the eventmachine thing is a good one
00:17:48  <txdv_>what I would emphasize in the talk that ALL APIS ARE ASYNC
00:17:51  <txdv_>and thats good
00:18:06  <txdv_>because in the .net world everyone fucks up every decent library with blocking stuff
00:18:16  <txdv_>they do not distinguish between data processing and control flow
00:18:51  <txdv_>it is possible and easy to integrate an async library into a blocking control flow
00:18:56  <txdv_>impossible the other way around
00:19:26  * lohkeypart
00:19:55  <piscisaureus_>bnoordhuis: is there a "view mode" somewhere, or do I have to clone?
00:20:09  <bnoordhuis>piscisaureus_: i think you'll have to clone it
00:20:23  <txdv_>bnoordhuis: lol node.js has less LOC than openssl
00:20:34  <txdv_>3 times less
00:20:38  <bnoordhuis>yeah. i even left out the asm bits
00:21:01  <bnoordhuis>i think that's a good thing though
00:21:13  <bnoordhuis>you can comprehend node core by reading the source for a day or two
00:21:29  <bnoordhuis>try that with e.g. the jvm
00:21:48  <txdv_>it is not fair to compare jvm and node core
00:21:52  <txdv_>you should have to compare jvm and v8
00:22:15  <bnoordhuis>okay, jvm + jdk
00:22:22  <txdv_>jdk to node core - yes
00:22:34  <txdv_>node basically exposes libuv
00:22:48  <txdv_>and cares
00:23:11  <txdv_>rubys core is compared to jdk small too
00:23:19  <txdv_>but it still has a lot of core libraries
00:23:45  <bnoordhuis>yeah, i was going to mention that and how it hampers progress
00:23:51  <bnoordhuis>but i only have a 40 minute time slot :)
00:24:48  <txdv_>what does 'no batteries included' mean?
00:25:52  <piscisaureus_>bnoordhuis: there's an empty bullet point after "no batteries included"
00:25:53  <bnoordhuis>txdv_: the opposite of the python attitude
00:26:07  <txdv_>and what is the python attiude?
00:26:07  <bnoordhuis>oh, right - i'll fix that
00:26:12  <bnoordhuis>txdv_: batteries included
00:26:15  <piscisaureus_>I go home at four <-- not a lie
00:26:24  <txdv_>yeah
00:26:26  <txdv_>good explanation
00:26:30  <bnoordhuis>piscisaureus_: i don't mention if it's am or pm :)
00:26:53  <bnoordhuis>txdv_: google can explain it better than i can
00:27:01  <txdv_>he goes home and codes on uv_file_t
00:27:27  <piscisaureus_>actually he never leaves home
00:27:53  <bnoordhuis>txdv_: in short, pythons standard lib is humongous and includes everything
00:28:20  <bnoordhuis>and i mean everything, from snmp to obscure windows apis
00:28:52  <bnoordhuis>but to quote kenneth reitz, python core is where modules go to die
00:29:06  <mmalecki>heh. I had this quote in my lxjs talk
00:29:11  <bnoordhuis>once they're in core, they can't be modified ever
00:29:16  <isaacs>bnoordhuis: yep.
00:29:21  <txdv_>bad politics
00:29:28  <isaacs>every module in core is a weakness.
00:29:29  <isaacs>and a cost.
00:29:41  <bnoordhuis>txdv_: not politics, backwards compatibility
00:29:50  <isaacs>bnoordhuis: but also, politics.
00:29:56  <txdv_>it is a political decision to take a module into the core
00:30:02  <isaacs>bnoordhuis: python tried to avoid chaos. they chose stagnation.
00:30:07  <isaacs>those are the only two choices.
00:30:10  <txdv_>because you ahve to interact with different people and agree upon something
00:30:20  <bnoordhuis>i think there's a lot of "it seemed like a good idea at the time" in there
00:30:25  <isaacs>putting something into the core lib of a platform is a hugely political decision.
00:30:39  <isaacs>but python's stdlib is to python what npm is to node.
00:30:46  <isaacs>because their package managers are abusively bad.
00:30:54  <bnoordhuis>yeah, no lie
00:31:00  <isaacs>but why have a good package manager when everythign you need is in core?
00:31:10  <isaacs>it becomes a cultural conundrum
00:31:19  * pooyaquit (Quit: pooya)
00:31:25  <chilts>I love how npm works and the fact that core is small :)
00:31:29  <txdv_>thank god someone created npm
00:31:38  <txdv_>or better thank the person directly
00:31:45  <isaacs>txdv_: :)
00:32:06  <txdv_>i guess you can count npm to node core
00:32:17  <isaacs>txdv_: it helped that ryah has kind of an insanely minimalist esthetic about what goes into a platform. npm was an idea waiting for a language to embrace it.
00:32:18  <txdv_>because without npm, node wouldn't be what it is today
00:32:20  <bnoordhuis>meh. i still use kiwi
00:32:31  <isaacs>bnoordhuis: lolz
00:32:33  <txdv_>kiwi?
00:32:36  <isaacs>bnoordhuis: i use sproutcore
00:32:38  <isaacs>seed?
00:32:49  <isaacs>txdv_: probably before your time :)
00:33:00  <isaacs>txdv_: an early competitor to npm by tjholowaychuk
00:33:14  <isaacs>at the time, i was working on a project i called mojito, which was a competitor to express.
00:33:22  <isaacs>well, to connect, since express didn't exist yet.
00:33:30  <isaacs>it's good that those things died.
00:33:47  <isaacs>so, it seems like res.on('finish') just pretty much never happens in master..
00:33:49  <isaacs>this is kind of odd.
00:34:04  <isaacs>of course, once res is a stream.Writable, then it'll be guaranteed.
00:34:08  <mmalecki>wasn't it renamed to `end`?
00:34:11  <isaacs>so probably no need to fix it.
00:34:13  <isaacs>mmalecki: !?!?!?!
00:34:17  <isaacs>writable streams cannot emit end!
00:34:26  <isaacs>when was that changed?
00:34:47  <isaacs>oh, that's so very very wrong.
00:34:49  <chilts>I'd love a cheatsheet on all this new stream stuff with which events happen, when and what they mean :)
00:34:54  * chiltsgets confused
00:35:02  <mmalecki> * http: make http.ServerResponse emit 'end' (Ben Noordhuis)
00:35:21  <mmalecki>790d651f0dfae13f1e2b799820ab18ac09f251b7
00:35:24  <isaacs>bnoordhuis: ! >.<
00:35:46  <isaacs>bnoordhuis: that's incorrect. 'end' events are for readable streams only.
00:35:55  <bnoordhuis>isaacs: i think you lgtm'd that
00:36:10  <isaacs>sounds like something i'd do.
00:36:18  * isaacspoints scowling smilies at himself, also.
00:36:29  <mmalecki>well, https://github.com/joyent/node/issues/3855
00:36:38  * c4miloquit (Remote host closed the connection)
00:36:40  <mmalecki>SO XD
00:36:41  * isaacsshrug.
00:36:51  <isaacs>hahahaah
00:36:54  <bnoordhuis>haha
00:37:04  <isaacs>not only did i lgtm it, i explicitly asked for it.
00:37:06  <isaacs>oh well, i was wrong :)
00:37:10  <isaacs>that's a bad idea.
00:37:17  <bnoordhuis>okay, revert it
00:37:21  <isaacs>if writable streams emit end, then that's very confusing for duplexes, that's the problem.
00:37:40  <isaacs>because you don't know if 'end' means 'writes are all flushed' or 'no more data comint'
00:38:56  <isaacs>bnoordhuis: sorry for casting aspersions your way. you were only giving the people what they thought they wanted.
00:39:48  <bnoordhuis>isaacs: no worries, i'm used to it. whenever we're out of something, my wife casts a lot of aspersions my way
00:40:01  <mmalecki>that's pretty common. it's called "relationship"
00:42:00  * erickt_joined
00:42:31  <MI6>joyent/node: isaacs master * 836a06f : Revert "http: make http.ServerResponse emit 'end'" This reverts commit 7 - http://git.io/4kxmZA
00:44:43  <MI6>joyent/node: isaacs streams2 * 42f1197 : Set flowing=true when flowing (+13 more commits) - http://git.io/BuV_-w
00:50:05  <TooTallNate>isaacs: idk if it's this new Transform API or just that I'm a better coder now, but my node-icecast rewrite looks like really clean code to me :) https://github.com/TooTallNate/node-icecast-stack/blob/19b90e753f38453e2ddf0677a60938ca7bc97122/lib/reader.js
00:51:22  <bnoordhuis>okay, off to bed - sleep tight everyone
00:52:36  <mmalecki>bnoordhuis: night
00:52:55  <txdv_>that wife
00:53:53  <txdv_>its 4 already
00:54:16  <txdv_>man time flies when you code and chat with awesome poeple
00:56:00  * bnoordhuisquit (Ping timeout: 260 seconds)
00:59:21  * TooTallNatequit (Quit: ["Textual IRC Client: www.textualapp.com"])
01:14:48  * perezdquit (Quit: perezd)
01:23:30  * erickt_quit (Quit: erickt_)
01:28:15  <piscisaureus_>i'm off, bye friends
01:28:19  * piscisaureus_quit (Quit: ~ Trillian Astra - www.trillian.im ~)
01:35:05  * erickt_joined
01:48:09  * c4milojoined
01:53:40  * perezdjoined
02:04:35  * abraxasjoined
02:08:52  * joshthecoderjoined
02:34:54  * loladirojoined
02:35:07  * ericktquit (Quit: erickt)
02:35:07  * erickt_changed nick to erickt
02:49:36  * bradleymeckjoined
02:49:58  <bradleymeck>anyone know a good place to get answers to gyp questions?
02:59:41  * mmaleckiquit (Ping timeout: 246 seconds)
03:03:10  <MI6>joyent/node: isaacs streams2 * d99d39c : setEncoding and abstract out endReadable - http://git.io/mm2x-g
03:11:03  * brsonquit (Quit: leaving)
03:24:47  * c4miloquit (Remote host closed the connection)
03:24:48  * bradleymeckquit (Quit: bradleymeck)
03:28:41  * lohkeyjoined
03:32:48  * pooyajoined
03:32:49  * pooyaquit (Client Quit)
03:54:37  * brsonjoined
04:06:44  * mmaleckijoined
04:10:56  * mmaleckiquit (Ping timeout: 240 seconds)
04:57:45  * ericktquit (Quit: erickt)
04:58:35  * lohkeypart
05:06:57  * kristatejoined
05:17:41  * Benviejoined
05:36:29  * AvianFluquit (Remote host closed the connection)
06:09:20  * mikealquit (Quit: Leaving.)
06:16:17  * perezdquit (Quit: perezd)
06:29:00  * loladiroquit (Quit: loladiro)
06:34:49  * brsonquit (Quit: leaving)
06:40:27  * loladirojoined
06:49:51  <indutny>ircretary: tell piscisaureus_ from Oct 15
06:49:52  <ircretary>indutny: I'll be sure to tell piscisaureus_
06:51:52  * rendarjoined
07:04:41  * mikealjoined
08:15:37  * mikealquit (Quit: Leaving.)
08:19:09  * bnoordhuisjoined
08:32:26  * loladiroquit (Quit: loladiro)
08:44:21  * bnoordhuisquit (Read error: Operation timed out)
08:44:25  * joshthecoderquit (Quit: Leaving...)
08:54:12  * V1joined
08:54:44  * V1changed nick to `3rdEden
08:57:36  * stagasjoined
09:19:41  * hzjoined
09:28:11  * kristatequit (Ping timeout: 246 seconds)
10:39:29  * mikealjoined
10:48:21  * mikealquit (Quit: Leaving.)
11:29:14  <txdv_>when I use queue_work
11:29:18  <txdv_>my vm won't quit
11:29:19  <txdv_>Oo
11:34:20  <indutny>nice
11:41:28  * stagasquit (Ping timeout: 240 seconds)
11:48:46  <txdv_>no nice
11:48:46  <txdv_>bad, very bad
11:49:00  <txdv_>or how the russians say: xuinia blet
11:54:03  <indutny>ok
11:54:14  <indutny>so loop is continuing running
11:56:38  <indutny>?
11:58:29  <txdv_>I really don't know
11:58:50  <txdv_>well it is a version with eio
12:01:16  <txdv_>i don't know how to debug this
12:01:20  <txdv_>mono is just not quitting
12:01:25  <txdv_>even though it goes through the main method
12:05:45  <indutny>txdv_: what if you'll break somewhere?
12:05:56  <indutny>txdv_: what backtrace will it have?
12:07:34  <txdv_>http://paste.ubuntu.com/1259838/
12:13:16  * AvianFlujoined
12:16:11  <indutny>txdv_: `bt` ?
12:18:27  <txdv_>what is bt
12:18:40  * bradleymeckjoined
12:22:46  <indutny>txdv_: command :) backrace
12:22:49  <indutny>backtrace*
12:25:20  <txdv_>http://paste.ubuntu.com/1259860/
12:25:41  <indutny>oh
12:25:45  <indutny>some mono crap apparently
12:26:08  <indutny>txdv_: please type `info threads`
12:26:19  <indutny>txdv_: then "t [thread num]" and "bt" for each thread
12:26:55  <txdv_>looks like that
12:31:38  <txdv_>http://paste.ubuntu.com/1259869/
12:31:43  <txdv_>thread nr 3 looks interesting
12:32:03  <txdv_>i am creating uv_async in order to make it possible to run RunNoWait on a loop
12:34:56  <txdv_>http://paste.ubuntu.com/1259876/
12:34:59  <txdv_>this is what is happening
12:35:09  <txdv_>at the c level
12:35:13  <txdv_>and the same thing happens
12:35:16  <txdv_>it just stops
12:36:03  <txdv_>or not
12:36:11  <txdv_>im unrefing the async
12:36:56  <txdv_>no, this code code works
12:38:34  * c4milojoined
12:39:47  <txdv_>in the C# it leaves the main method
12:41:16  <txdv_>indutny: does that start mean that it is in the thread number 3?
12:41:21  <txdv_>blocking on write in the async_send?
12:41:35  <indutny>txdv_: well, it just interrupted there
12:41:42  <indutny>it doesn't means that it's blocking there
12:41:49  <indutny>you can do following thing
12:41:50  <indutny>t 3
12:41:52  <indutny>s
12:41:53  <indutny>s
12:41:53  <indutny>s
12:41:58  <indutny>and look if it'll go further
12:46:49  <txdv_>it does
12:48:23  <txdv_>looks like a semaphore deadlock
12:48:45  <txdv_>but everything happens in mono
12:48:51  * bradleymeckquit (Quit: bradleymeck)
12:48:53  <txdv_>how can libuv make that happen Oo
12:48:56  <indutny>semaphores are ok
12:49:04  <indutny>that's how things works
12:49:11  <indutny>each eio worker is waiting on semaphore
12:50:14  * c4miloquit (Remote host closed the connection)
12:53:14  <txdv_>freaking mystery
13:07:35  <txdv_> System.Diagnostics.Process.GetCurrentProcess().Kill();
13:07:41  <txdv_>great, now i hve to call this monster
13:07:41  <txdv_>xD
13:08:58  <MI6>joyent/node: koichik v0.8 * fbb0ee6 : buffer: fix byteLength with UTF-16LE Fixes #4075. - http://git.io/VHpdSw
13:12:47  * mmaleckijoined
13:13:40  * abraxasquit (Remote host closed the connection)
13:14:18  * mmaleckiquit (Client Quit)
13:15:37  * mmaleckijoined
13:16:57  * sergimjoined
13:19:04  * c4milojoined
13:27:02  * hzquit (Disconnected by services)
13:27:08  * hzjoined
13:34:22  * abraxasjoined
13:43:30  * stagasjoined
13:49:24  <c4milo>why libuv didn't adopt posix error codes as the canonical codes and instead created its own codes? >.<
13:51:42  * bradleymeckjoined
13:57:54  * stagasquit (Ping timeout: 246 seconds)
13:58:06  * c4miloquit (Remote host closed the connection)
13:58:39  * piscisaureus_joined
13:58:55  <piscisaureus_>ircretary: notes
14:00:01  <bradleymeck>has anyone had trouble linking to uv.a on smartos64? ala gcc deps/uv/uv.a src/program.c
14:02:30  * loladirojoined
14:03:28  * mikealjoined
14:06:46  * loladiroquit (Client Quit)
14:23:09  * ericktjoined
14:28:16  * tomshredsjoined
14:44:04  * mikealquit (Quit: Leaving.)
14:44:54  * bradleymeckquit (Quit: bradleymeck)
14:45:00  * mikealjoined
14:52:47  * bradleymeckjoined
14:53:58  <MI6>joyent/libuv: piscisaureus created branch condvars - http://git.io/evkTuQ
14:54:23  * loladirojoined
14:56:11  <MI6>joyent/libuv: Bert Belder condvars * 374e337 : move "typedef PVOID CONDITION_VARIABLE" to it's final position - http://git.io/Z65RUA
14:58:48  * bradleymeckquit (Ping timeout: 240 seconds)
15:00:16  * bradleymeckjoined
15:09:03  * loladiroquit (Quit: loladiro)
15:11:03  * c4milojoined
15:15:15  * AndreasMadsenjoined
15:15:37  * TheJHjoined
15:15:51  * AndreasMadsenquit (Remote host closed the connection)
15:16:04  * AndreasMadsenjoined
15:18:35  * AndreasMadsenquit (Remote host closed the connection)
15:23:30  * `3rdEdenchanged nick to `3E|Dinner
15:23:58  * loladirojoined
15:26:18  * stagasjoined
15:29:35  * mikealquit (Quit: Leaving.)
15:31:41  * loladiroquit (Quit: loladiro)
15:33:36  <isaacs>indutny: piscisaureus_ bnoordhuis TooTallNate: Call in 0:30
15:33:43  <isaacs>0:28, actually :)
15:33:53  <piscisaureus_>isaacs: I think bnoordhuis won't join
15:33:58  <isaacs>ok
15:34:03  <piscisaureus_>but I will
15:34:07  <isaacs>that's too bad. i hope he's ok.
15:34:17  <piscisaureus_>isaacs: he's at a conference
15:34:28  <isaacs>sounds fancy. :)
15:34:32  <isaacs>which one?
15:34:39  <piscisaureus_>some rails conf
15:34:54  <isaacs>huh. i never knew ben was a rails guy...
15:35:05  <piscisaureus_>I think
15:35:06  <piscisaureus_>http://arrrrcamp.be/
15:35:30  * loladirojoined
15:35:33  <isaacs>ohh, now a PIRATE conference, that makes a lot of sense.
15:35:49  * isaacscould totally see bnoordhuis as a pirate
15:36:07  <piscisaureus_>I stick to the squatter image
15:37:47  * loladiroquit (Client Quit)
15:38:00  <isaacs>piscisaureus_: got setEncoding working last night
15:38:07  <piscisaureus_>isaacs++
15:38:10  <isaacs>piscisaureus_: also, new Readable({ encoding: 'utf8' }) also works
15:38:20  <isaacs>it was actually not all that hard.
15:38:24  <piscisaureus_>http://i151.photobucket.com/albums/s135/aeonnz/animated/youknow.gif
15:38:29  <isaacs>but it does still expect _read(n,cb) to return buffers, and not strings.
15:39:06  <piscisaureus_>isaacs: ok, let's discuss this at the call. I am trying to finish multiloop signals before it :-)
15:39:14  <isaacs>great :)
15:39:23  <piscisaureus_>execSync ftw :-p
15:39:48  <piscisaureus_>took only one year to fix :-(
15:39:48  * loladirojoined
15:42:37  * ericktquit (Quit: erickt)
15:53:04  * sergimquit (Quit: Textual IRC Client: http://www.textualapp.com/)
15:54:45  * TooTallNatejoined
16:00:18  <isaacs>!!!!
16:00:21  <isaacs>piscisaureus_: srslly?
16:00:25  <isaacs>that's badass.
16:00:34  <TooTallNate>what'd I miss?
16:00:48  <isaacs>TooTallNate: execSync
16:03:06  <piscisaureus_>isaacs: can I have 4 more minutes?
16:03:17  <piscisaureus_>isaacs: need to switch laptops
16:03:26  <isaacs>k
16:03:31  <isaacs>you may have 4 minutes.
16:04:04  <indutny>callllll
16:11:01  * Raltquit (Ping timeout: 260 seconds)
16:11:01  <rendar>execSync doesn't seem a libuv api, whats that? :)
16:17:08  * AndreasMadsenjoined
16:17:12  <CoverSlide>does it block until execution is done, or is it more like python's popen?
16:19:28  * bradleymeckquit (Quit: bradleymeck)
16:20:50  * stagasquit (Ping timeout: 256 seconds)
16:22:11  * loladiroquit (Quit: loladiro)
16:22:35  * AndreasMadsenquit (Remote host closed the connection)
16:22:43  * AndreasMadsenjoined
16:22:58  * AndreasMadsenpart
16:23:52  * mikealjoined
16:30:26  <indutny>piscisaureus_: so
16:30:31  <indutny>piscisaureus_: I've a question
16:30:54  <indutny>why are we using only one pipe for all async handles in uv
16:31:17  <indutny>it seems that we're wasting time checking all handles that are currently in the loop
16:31:33  <indutny>it works, but we can do better
16:31:51  <indutny>piscisaureus_: what do you think?
16:38:56  <piscisaureus_>indutny: not sure, ben wrote that
16:38:59  <indutny>ah
16:39:03  <indutny>how does it works on windows?
16:39:04  * loladirojoined
16:39:08  <piscisaureus_>indutny: I know libev did the same, but I agree it seems rather silly
16:39:25  <piscisaureus_>indutny: very different. It posts a completion packet
16:39:33  <indutny>piscisaureus_: ah
16:39:42  <indutny>piscisaureus_: so that packet has associated info within
16:39:46  <indutny>like that?
16:40:02  <piscisaureus_>indutny: well, that package is pre-allocated and embedded into the uv_async_t struct
16:40:09  <indutny>ok
16:40:15  <piscisaureus_>so by looking at the pointer we can tell which async it was form
16:40:25  <indutny>ah
16:40:27  <indutny>good
16:40:38  <indutny>probably we can do quite the same thing with pipes
16:40:45  <indutny>write pointers to it
16:40:53  <piscisaureus_>indutny: you could also think of using a single pipe but writing the pointer to the async to it
16:40:53  <indutny>ah, that's not atomic
16:40:58  <piscisaureus_>yeah
16:41:09  <piscisaureus_>but uv_signal does it also
16:41:39  <piscisaureus_>indutny: it would work if you would put a mutex around the write() call
16:41:58  <indutny>surely it will
16:42:03  <piscisaureus_>but then... would that be any faster ?
16:42:04  <indutny>but that's not as good :)
16:42:08  <indutny>indeed
16:42:19  <indutny>though pipes a quite fast
16:42:34  <indutny>and sending multiple asyncs from different threads
16:42:36  <indutny>is not really the case
16:43:15  <piscisaureus_>maybe you can use some trickery
16:43:33  <piscisaureus_>so non atomic writes would be detectable
16:43:43  * bradleymeckjoined
16:43:53  <piscisaureus_>like utf8 does it
16:45:17  <indutny>huh?
16:45:24  <piscisaureus_>well
16:45:26  <indutny>what do you mean by detectable here
16:45:33  <indutny>what's the purpose of detection of non-atomic writes
16:45:42  <piscisaureus_>well, what is the problem with writing pointers?
16:45:56  <indutny>you can get half of one pointer and half of another :)
16:46:06  <piscisaureus_>well, no
16:46:07  <indutny>first halfes
16:46:12  <piscisaureus_>yeah
16:46:22  <piscisaureus_>you see half of one and half of another
16:46:26  <piscisaureus_>that's bad
16:46:32  <piscisaureus_>but if you encode the pointer somehow
16:46:49  <piscisaureus_>so you can distinguish the first byte from the second one etc
16:46:58  <piscisaureus_>then it's no longer a problem
16:47:32  <TooTallNate>indutny: are you familiar with the rules of dlopen()?
16:47:36  <piscisaureus_>indutny: I think write()'s are atomic right? The only problem is when they are interrupted
16:47:49  <TooTallNate>or piscisaureus_ ^
16:47:59  <indutny>piscisaureus_: they're
16:48:01  <piscisaureus_>TooTallNate: what's the question?
16:48:15  <indutny>piscisaureus_: I don't think that this stuff really works :)
16:48:24  <indutny>piscisaureus_: marking bytes
16:48:40  <indutny>piscisaureus_: well, it may work with two concurrent threads
16:48:49  <indutny>piscisaureus_: and two-byte sequences
16:48:49  <TooTallNate>piscisaureus_: if I'm trying to dlopen a lib that dynamically links to some other (not yet loaded) lib, how am I supposed to do that?
16:48:57  <TooTallNate>piscisaureus_: context: https://github.com/rbranson/node-ffi/issues/80
16:49:07  <indutny>piscisaureus_: (though I don't know how)
16:49:19  <indutny>TooTallNate: load those libs first
16:49:52  <piscisaureus_>indutny: I think that unix requires that pipe writes are always atomic below a certain limit, actually
16:49:54  <TooTallNate>indutny: wouldn't i have to use RTLD_GLOBAL for that?
16:50:03  <piscisaureus_>indutny: http://pubs.opengroup.org/onlinepubs/009695399/functions/write.html
16:50:05  <indutny>piscisaureus_: that's a subject for discussion
16:50:08  <indutny>piscisaureus_: we need ben for that
16:50:18  <indutny>TooTallNate: I'm not familiar with this
16:50:21  <indutny>unfortunatelly
16:50:25  <TooTallNate>indutny: ok :p
16:50:38  <TooTallNate>tjfontaine: i'm thinking of making DynamicLibrary use RTLD_LAZY by default
16:51:00  <tjfontaine>TooTallNate: ya, I am reading through this, I'm thinking that might be the answer
16:51:06  <TooTallNate>tjfontaine: ya me too
16:52:06  <piscisaureus_>indutny: also see http://linux.die.net/man/7/pipe
16:52:21  <indutny>piscisaureus_: oh
16:52:29  <indutny>piscisaureus_: so writing less than PIPE_BUF should be always atomic
16:52:33  * ericktjoined
16:52:42  <piscisaureus_>indutny: yes
16:52:50  <piscisaureus_>indutny: that's specific for pipes, tho
16:53:10  <indutny>indeed
16:53:13  <indutny>that's what we need
16:54:36  <tjfontaine>TooTallNate: I dunno though, it should work fine with liba loading before libb, we should probably make a small test case
16:54:38  * paddybyersjoined
16:54:52  <piscisaureus_>TooTallNate: RTLD_GLOBAL indeed
16:55:18  <tjfontaine>we can or with RTLD_NOW|RTLD_GLOBAL
16:55:52  <TooTallNate>tjfontaine: global shouldn't be default i don't think
16:55:57  <tjfontaine>no no
16:56:13  <tjfontaine>but you can specify with Dynamic right?
16:57:17  <tjfontaine>TooTallNate: he needs to load liba with DynamicLibrary and FLAGS.RTLD_GLOBAL
16:57:39  <TooTallNate>tjfontaine: right, that'll solve his problem
16:57:47  <tjfontaine>and doesn't break the rest of ffi
16:58:16  * Raltjoined
16:58:23  <TooTallNate>tjfontaine: lol, the dlopen man page basically spells out his problem for us:
16:58:25  <TooTallNate>"RTLD_LAZY is normally preferred, for reasons of efficiency. However, RTLD_NOW is useful to ensure that any undefined symbols are discovered during the call to dlopen()."
16:58:53  <TooTallNate>we use RTLD_NOW… and he's getting undefined symbols :p
16:59:22  <tjfontaine>ya, and it goes on to say or with global for dependent libraries :)
17:00:24  * perezdjoined
17:01:42  <TooTallNate>tjfontaine: it looks like RTLD_GLOBAL is already the default
17:01:48  <TooTallNate>"If neither RTLD_GLOBAL nor RTLD_LOCAL is specified, the default is RTLD_GLOBAL."
17:02:03  <TooTallNate>however that's osx, the linux man page for it says the inverse ;)
17:02:48  <tjfontaine>right
17:03:00  <tjfontaine>was going to say, that's not what I just read on my vm :)
17:03:36  * loladiroquit (Quit: loladiro)
17:03:48  <TooTallNate>weird
17:04:32  <tjfontaine>so anyway, explicit is better for him in this case for cross platform work
17:04:56  * bradleymeckquit (Quit: bradleymeck)
17:04:58  <tjfontaine>unless you want ffi to behave the same regardless
17:05:34  <TooTallNate>i think we just leave the global/local default up to the OS
17:05:39  * `3E|Dinnerchanged nick to `3rdEden
17:05:51  <TooTallNate>but for him, he's gonna need to explicitly specify GLOBAL
17:05:55  <tjfontaine>I agree
17:07:43  * bradleymeckjoined
17:07:54  * bradleymeckquit (Client Quit)
17:14:11  <isaacs>hm.... Transform stream is all wrong.
17:14:19  <isaacs>the api is nice, but it's doing the wrong thing
17:14:39  <isaacs>it's accepting all writes unconditionally, even if there's no reader consuming them
17:18:03  * mikealquit (Quit: Leaving.)
17:20:33  * lohkeyjoined
17:22:13  * c4miloquit (Remote host closed the connection)
17:27:42  <TooTallNate>isaacs: i think that's the bug I was seeing :)
17:28:05  <isaacs>TooTallNate: in some cases, this can lead to end being emitted in the wrong place, which is horrible.
17:28:20  <isaacs>TooTallNate: so, what i think i have to do is this:
17:28:30  <isaacs>TooTallNate: _write(chunk,cb) puts it in a queue
17:28:41  <isaacs>(puts both the chunk and the cb together in a queue, i mean)
17:29:13  <isaacs>TooTallNate: then, _read(n,cb) tells it to pull one of the chunks out of the _write queue, and call _transform(chunk,output,cb) on it
17:30:02  <isaacs>TooTallNate: and it'll just keep calling _transform() until it's filled up the read buffer with n bytes of chunks, then call the _read cb
17:30:02  <TooTallNate>sounds reasonable
17:30:34  <isaacs>or, maybe, like it does now, *not* call the _read cb, and just emit readable itslef, unless i'ts empty and finished
17:59:02  * c4milojoined
18:01:39  * brsonjoined
18:01:58  * wankdankerjoined
18:04:52  <wankdanker>anyone around who has a minute or two to answer some uv_queue_work questions?
18:05:26  * pooyajoined
18:07:45  <saghul>wankdanker just ask, someone will probably read it and answer :-)
18:08:24  <wankdanker>i don't know exactly how to phrase the question without interactin or rambling on... but i'll give it a shot ;)
18:10:23  <wankdanker>let's say I have an AsyncWork function that all it does is call sleep(x) where x is passed in from javascript land
18:11:12  * `3rdEdenquit (Remote host closed the connection)
18:11:14  <wankdanker>if i call this function 5 times passing x each time decrementing x
18:12:53  <wankdanker>for some reason, i feel like i should get the results back from the last called function where x was 0 first
18:14:56  <wankdanker>here is code: https://gist.github.com/3835374
18:15:06  * ericktquit (Quit: erickt)
18:16:39  <wankdanker>what I expect to see is not happening, which leads me to believe that what I expect is wrong because I misunderstand how uv_queue_works.
18:17:03  * kazuponjoined
18:17:41  <wankdanker>i would expect that the results of sleep(0) return first even though it was queued last, sleep(1) to return second even though it was queued second to last, etc.
18:18:57  <wankdanker>what I am seeing is that results in this order: sleep(2), sleep(3), sleep(0), sleep(1), sleep(4), sleep(5)
18:18:59  * ericktjoined
18:23:26  * V1joined
18:23:51  * paddybyersquit (Ping timeout: 255 seconds)
18:23:56  * V1changed nick to `3rdEden
18:24:19  <wankdanker>what is additionally interesting to me about this is that sleep(3), sleep(0) and sleep(1) all seem to finish "at the same time"
18:24:35  <indutny>pquerna: heya
18:24:38  <indutny>pquerna: yt?
18:24:44  <pquerna>indutny: yo
18:24:53  <indutny>pquerna: I need your help once again
18:25:21  <indutny>pquerna: I've fixed SSL read errors and length errors once
18:25:34  <indutny>pquerna: but now after moving everything to lockless buffers it seems to be happening again
18:25:37  * Raltquit (Remote host closed the connection)
18:25:46  <indutny>pquerna: but this time I think it's just disconnecting before client does it
18:26:00  <indutny>pquerna: since all requests are successfull, and there're no length error (in apache benchmark)
18:26:12  <indutny>pquerna: what's a proper way to terminate connection with client?
18:26:14  * Raltjoined
18:26:28  <pquerna>both sides send a close notify
18:26:42  <pquerna>and then its over... which should be once ssl_shutdown returns.....
18:26:48  <indutny>pquerna: SSL_shutdown should make it?
18:27:07  <indutny>pquerna: so SSL_shutdown return zero for me
18:27:16  <pquerna>it should eventually return 1
18:27:35  <pquerna>once the other side sends a close notify
18:27:58  <indutny>pquerna: ah
18:28:02  <indutny>pquerna: so zero is bad
18:28:37  <pquerna>god
18:28:42  <pquerna>i wanted to see what HTTPD is doing
18:28:46  <indutny>:)
18:29:08  <pquerna>https://github.com/apache/httpd/blob/trunk/modules/ssl/ssl_util_ssl.c#L165
18:29:14  <pquerna>it just calls SSL_Shutdown 4 times
18:29:28  <pquerna>why? no one knows!
18:29:41  <indutny>ahhaha
18:30:02  <indutny>crap, this shit is hard
18:30:11  <indutny>ok
18:30:15  <indutny>so I replaced check
18:30:23  <pquerna>i think a best guess
18:30:33  <indutny>and I'm getting SSL read failures every time now :D
18:30:34  <pquerna>would be to call it once, make sure that returns 0 or 1
18:30:42  * Raltquit (Ping timeout: 248 seconds)
18:30:43  <pquerna>then next 3-4 times there is io
18:30:49  <pquerna>make sure it returns 1 within that
18:30:50  <indutny>pquerna: IO?!
18:30:53  <pquerna>or then terminate it
18:30:58  <indutny>pquerna: how can it make IO
18:31:00  <pquerna>like you got data from the peer of some kind
18:31:01  <indutny>it's just operating buffers
18:31:09  <pquerna>yeah, but the peer buffer got 'something'
18:31:14  <indutny>well, I'm doing that in separate cycle
18:31:19  <pquerna>if it still returns 0, give up
18:31:25  <pquerna>because it could be a 'bad' client
18:31:29  <pquerna>whcih isn't sending a close notify
18:31:34  <pquerna>so you should give up anways
18:31:42  <indutny>ok
18:31:47  <indutny>got it
18:31:53  <pquerna>afk meeting
18:32:00  <indutny>thanks
18:43:40  <indutny>pquerna: SSL_ERROR_SYSCALL
18:43:44  <indutny>pquerna: wtf?! )
18:47:54  <saghul>wankdanker it's a thread pool, operations are not serialized
18:48:03  <saghul>wankdanker they may run in parallel
18:48:23  <wankdanker>saghul: i think what i'm seeing is that there are only 4 threads (probably one per core)
18:48:36  <saghul>wankdanker that's a fixed value for now
18:48:49  <wankdanker>ok.
18:48:51  <saghul>you would still have 4 threads even with 64 cores
18:48:57  <wankdanker>gotcha.
18:49:43  <wankdanker>so what i was just doing was a test for my real problem, which is binding for odbc. we use uv_queue_work, but that basically means there can only ever be a maximum of four concurrent database queries
18:49:59  <wankdanker>because it's not really cpu bound, it's mostly io as long as its a remote server
18:50:36  <saghul>then can't you have a pool of uv_tcp handles perhaps?
18:52:12  <wankdanker>i'm not sure. these are bindings to the unix odbc module.
18:52:39  <wankdanker>i wouldn't have any idea where to begin with a pool of uv_tcp handles. :-\
18:52:54  <wankdanker>err unixodbc library, sorry
18:55:06  <indutny>pquerna: yay, I've fixed it
18:55:09  <indutny>pquerna: thank you!!!
18:57:23  <pquerna>sweet
18:58:37  <indutny>yay
18:58:39  <indutny>it's as fast as nginx now
18:58:46  <indutny>almost
18:58:48  <indutny>4500 req/sec
18:58:52  <indutny>4673
18:58:58  <indutny>omg
18:59:01  <indutny>isaacs: ^^
18:59:09  <indutny>4805
18:59:29  <isaacs>indutny: ++ !!!!
18:59:33  <indutny>ok, I'm going to run whole set of benchmarks now
18:59:37  <indutny>to verify results
18:59:55  <isaacs>indutny: irssi is not capable of displaying emoji properly, and anyway, there is no emoji to properly express my happiness about that :)
19:00:09  <piscisaureus_>indutny: if that's true, it's amazing!!
19:00:15  <indutny>oh wait
19:00:20  <indutny>oh noes
19:00:21  * isaacsuh oh
19:00:24  <indutny>I was benchmarking nginx :D
19:00:26  <indutny>hahahaha
19:00:28  <isaacs>haha
19:00:30  <CoverSlide>:p
19:00:36  <isaacs>that explains why it's as fast as nginx!
19:00:47  <indutny>indeed
19:00:56  <indutny>I wonder why node have not complained about used port
19:02:46  <indutny>haha
19:02:46  <indutny>no
19:02:53  <indutny>it does 3500 req/sec
19:03:13  <indutny>but that was so good feeling!
19:03:39  <piscisaureus_>3500 is not bad
19:04:01  * lohkeyquit (Read error: Connection reset by peer)
19:04:10  <indutny>I wonder why load is so low
19:04:20  <indutny>piscisaureus_: that's on dedicated Xeon
19:04:32  <indutny>load is about 12
19:04:41  <piscisaureus_>indutny: your benchmarking tool is maxed out? of do you have multiple client machines?
19:04:52  <indutny>piscisaureus_: I'm using the same server
19:05:01  <indutny>piscisaureus_: that's incorrect, but I don't have two
19:05:09  <txdv_>what is emoji
19:05:11  <indutny>anyway it's not saturated enough
19:05:12  * lohkeyjoined
19:05:40  <piscisaureus_>maybe we should ask claudio if we can use the benchmark stuff again?
19:06:25  <indutny>who is he?
19:06:28  <indutny>what benchmark stuff?
19:06:36  <indutny>btw, I think it won't be really useful
19:08:41  <indutny>oh shit
19:08:47  <indutny>sometimes connections are hanging
19:08:47  <indutny>ok
19:08:50  <indutny>better go sleeping now
19:09:03  <indutny>good thing is I got this thingy dingy working almost without locks
19:09:15  <indutny>feat will be tomorrow
19:09:19  <indutny>pquerna: thanks again
19:09:23  <indutny>that was really helpful
19:10:37  * AvianFluquit (Remote host closed the connection)
19:13:13  <indutny>piscisaureus_: oh, I've one more idea
19:13:19  <indutny>piscisaureus_: with my own custom BIO buffers
19:13:25  <indutny>piscisaureus_: I can write into them directly
19:13:32  <indutny>without calling BIO_write
19:13:35  <piscisaureus_>indutny: that'd be cool
19:13:36  <indutny>and same for reading
19:13:37  <indutny>yeah
19:13:43  <indutny>I only need to set/reset few flags
19:13:53  <indutny>btw
19:13:59  <indutny>what do you know about memory barriers?
19:14:07  <pquerna>yea, custom BIOs might be worth it if you want more control or to do write completion io on them...
19:14:21  <piscisaureus_>indutny: what do you want to know about memory barriers?
19:14:51  <indutny>pquerna: I think I just want to skip redundant copying right now
19:15:00  <indutny>piscisaureus_: I'm using __sync_fetch_and_add now
19:15:06  <indutny>piscisaureus_: and going to move to memory barriers
19:15:20  <indutny>piscisaureus_: if I'll write OSMemoryBarrier() before a += 1
19:15:25  <indutny>will it be atomic?
19:15:30  <piscisaureus_>indutny: no
19:15:33  <indutny>oh
19:15:35  <indutny>well
19:15:39  <indutny>that's pretty shitty
19:15:44  * paddybyersjoined
19:15:51  <piscisaureus_>indutny: what's wrong with __sync_fetch_and_add ?
19:16:00  <indutny>piscisaureus_: it's not supported on old versions of gcc
19:16:09  <piscisaureus_>indutny: you can use inline asm
19:16:10  <indutny>and idk if it's supported in other compilers
19:16:22  <indutny>piscisaureus_: sure I can
19:16:26  <indutny>but I don't want to
19:16:27  <piscisaureus_>although it's pretty shitty to get right on arm :-)
19:16:27  <indutny>:)
19:16:33  <indutny>indeed
19:16:38  <indutny>I can wrap it with mutexes on arm
19:16:40  <indutny>I suppose
19:16:49  <indutny>I don't think it will hit performance much
19:16:50  <indutny>at least on arm
19:16:51  <indutny>:D
19:17:35  <txdv_>so it looks like snappy will be the fastest tls implementation on node?
19:18:39  * kazuponquit (Remote host closed the connection)
19:18:42  <indutny>not so far
19:18:55  <indutny>there're some balancing problems that I haven't yet solved
19:23:29  * `3rdEdenquit (Remote host closed the connection)
19:27:04  * lohkeyquit (Quit: lohkey)
19:41:41  * AndreasMadsenjoined
19:42:45  * AndreasMadsenquit (Remote host closed the connection)
19:48:59  * kazuponjoined
19:50:02  * Raltjoined
19:54:39  * `3rdEdenjoined
19:56:32  * kazuponquit (Ping timeout: 260 seconds)
20:09:06  <txdv_>the process_options wrapper is fiddle work
20:12:36  * tommybergeronjoined
20:16:15  * tomshredsquit (Ping timeout: 240 seconds)
20:18:06  * lohkeyjoined
20:19:26  <txdv_>is there any reason not to uv_close a uv_process_t on exit_cb?
20:20:18  * TooTallNatequit (Quit: Computer has gone to sleep.)
20:22:37  * kazuponjoined
20:26:33  * `3rdEdenquit (Quit: Zzz)
20:29:51  * kazuponquit (Ping timeout: 255 seconds)
20:33:49  * Raltquit (Remote host closed the connection)
20:33:57  <MI6>joyent/node: isaacs streams2 * 8f1cf4f : streams2: Make Transform streams pull-style That is, the transform is tr - http://git.io/mnoVsA
20:34:13  <isaacs>TooTallNate: ^
20:34:20  * Raltjoined
20:34:28  <isaacs>ircretary: tell TooTallNate < MI6> joyent/node: isaacs streams2 * 8f1cf4f : streams2: Make Transform streams pull-style That is, the transform is tr - http://git.io/mnoVsA
20:34:28  <ircretary>isaacs: I'll be sure to tell tootallnate
20:35:58  <txdv_>why aren't you doing it a seperate npm module?
20:38:40  * ericktquit (Quit: erickt)
20:38:55  * Raltquit (Ping timeout: 244 seconds)
20:39:38  * ericktjoined
20:42:29  <isaacs>txdv_: yeah, i'm finding new bugs as i try to merge it into node-core :)
20:42:37  <isaacs>txdv_: on the streams2 branch, zlib is using the new api
20:54:18  <txdv_>holy macarony
20:56:45  * kazuponjoined
20:59:12  <txdv_>freaking browser
20:59:18  <txdv_>i open it to do A and then end doing Z
21:05:08  * kazuponquit (Ping timeout: 260 seconds)
21:07:54  * stagasjoined
21:23:17  * c4miloquit (Remote host closed the connection)
21:24:46  * rendarquit
21:25:16  * c4milojoined
21:27:54  <saghul>hoi! whats the 'official' recommendation with regards to libuv and forking? There is no ev_fork thing, but do we need one?
21:29:00  <piscisaureus_>the official recommendation is, don't :-)
21:29:02  <piscisaureus_>ehm
21:29:43  <piscisaureus_>the problem here is not only specific issues with the poll backend (which i forgot, but ev_fork solves) but also that all threads are lost when you fork
21:30:01  <piscisaureus_>and libuv creates a thread pool and sometimes others
21:30:13  <piscisaureus_>saghul: ^
21:30:16  <saghul>piscisaureus_ thanks!
21:30:38  * TheJHquit (Ping timeout: 256 seconds)
21:31:04  * kazuponjoined
21:31:14  * ericktquit (Quit: erickt)
21:32:05  * AvianFlujoined
21:33:42  * ericktjoined
21:38:22  <indutny>oh
21:38:26  * kazuponquit (Ping timeout: 248 seconds)
21:38:29  <indutny>piscisaureus_: you said you can ask someone to benchmark it?
21:38:57  <piscisaureus_>indutny: no - but at some point we could use a testing setup at microsoft
21:39:04  <indutny>oh
21:39:05  <indutny>that
21:39:08  <piscisaureus_>some beefy (real) machines and a fast network
21:39:53  <indutny>yeah
21:39:54  <indutny>and windows
21:40:04  <piscisaureus_>indutny: we also had linux then
21:41:09  * TooTallNatejoined
21:41:30  * pooyaquit (Quit: pooya)
21:43:12  * c4miloquit (Remote host closed the connection)
21:51:35  * hzquit
21:52:49  <wankdanker>saghul mentioned earlier that the the eio thread pool is currently fixed to 4 threads
21:53:14  <wankdanker>correct me if I'm wrong, but it seems that the windows thread pool defaults to a max of 512
21:53:21  <saghul>wankdanker libuv no longs uses libeio
21:53:25  <wankdanker>damn
21:53:32  <wankdanker>what is it using for queue_work?
21:53:35  <saghul>it's a custom one now
21:53:44  <piscisaureus_>wankdanker: yes, that's true
21:54:01  <saghul>it's now daft punk stype: harder, better, faster, stronger! xD
21:54:10  <wankdanker>is the custom one not in the current node (v0.8) ?
21:54:19  <piscisaureus_>wankdanker: we will make the unix thread pool smarter in the future
21:54:54  <wankdanker>to me, it looks like node v0.8 is still using eio, is this changed in v0.9?
21:55:03  <piscisaureus_>wankdanker: And I think I will use it for windows as well. Windows' thread pool is quite "intelligent" but has too much overhead for my liking
21:55:20  <piscisaureus_>wankdanker: only in libuv master so far.
21:55:37  <piscisaureus_>wankdanker: 0.8 still has both ev and eio
21:55:43  <wankdanker>ok. any plans on when that is going to land into a stable node?
21:55:51  <piscisaureus_>in node 0.10
21:56:09  <wankdanker>ok. excellent. thank you for the information piscisaureus_
21:58:23  <wankdanker>and thank you saghul
22:05:17  * kazuponjoined
22:13:07  * kazuponquit (Ping timeout: 264 seconds)
22:14:16  * stagasquit (Ping timeout: 240 seconds)
22:14:28  * ericktquit (Quit: erickt)
22:15:26  * ericktjoined
22:20:24  * mikealjoined
22:26:26  <saghul>gevent + libuv = uvent https://github.com/saghul/uvent :-)
22:28:55  * c4milojoined
22:30:24  <piscisaureus_>saghul: kewl
22:31:29  <piscisaureus_>saghul: libev priorities is bullshit anyway. don't worry about it
22:35:42  <mmalecki>piscisaureus_: when are you getting into Paris?
22:35:51  <mmalecki>we might accidentally run into each other.
22:36:56  * perezdquit (Quit: perezd)
22:39:28  * perezdjoined
22:39:31  * kazuponjoined
22:43:00  <piscisaureus_>mmalecki: dotjs
22:43:06  <piscisaureus_>mmalecki: i think november 30th
22:44:58  <piscisaureus_>saghul: your site is down...
22:45:18  <piscisaureus_>oh well it's slow :-)
22:45:59  <saghul>piscisaureus_ stupid posterous… always down when you need them!
22:46:02  <piscisaureus_>1) Is it possible to implement libev on top of libuv with uvent as abstraction layer between them?
22:46:06  <piscisaureus_>^-- ehh?
22:46:40  <saghul>Nope, uvent is the genet core, but using libuv sited of libev
22:46:50  <saghul>s/genet/gevent/
22:46:52  * kazuponquit (Ping timeout: 260 seconds)
22:47:04  <piscisaureus_>saghul: that's a comment on your blog post
22:47:14  <saghul>fun
22:47:21  <saghul>it's down for me now :-S
22:47:35  <piscisaureus_>haha
22:48:13  <saghul>and I thought not hosting it myself would save me some trouble...
23:00:29  * erickt_joined
23:01:27  * ericktquit (Ping timeout: 246 seconds)
23:01:27  * erickt_changed nick to erickt
23:13:44  * kazuponjoined
23:20:44  * kazuponquit (Ping timeout: 245 seconds)
23:40:35  * tommybergeronchanged nick to tomshreds
23:47:36  <piscisaureus_>ok, time to go
23:47:43  * kazuponjoined
23:47:45  <piscisaureus_>tomorrow is conference crashing time
23:49:32  <isaacs>TooTallNate: png
23:49:37  <isaacs>TooTallNate: quick question...
23:50:04  <isaacs>TooTallNate: so... i set up the transform class to only actually do _transforms when you read bytes out.
23:51:02  <isaacs>TooTallNate: however, now the test/simple/test-zlib-invalid-input.js is failing, because if no one ever reads it, it never finds out it's invalid.
23:51:10  <isaacs>which is fine, i mean, that test is testing something you shouldn't do anyway;
23:51:32  <isaacs>but it makes me wonder... maybe _write should automatically do at least one transform, just to preload a little orsomething?
23:53:01  * kazuponquit (Read error: Connection reset by peer)
23:53:10  * kazuponjoined