00:05:14  * brsonjoined
00:32:37  * mikealquit (Quit: Leaving.)
00:34:51  * piscisaureus_joined
00:35:16  * mikealjoined
00:35:32  <piscisaureus_>hello
00:35:38  <piscisaureus_>anything interesting going on?
00:39:09  <bnoordhuis>we were just discussing the finer points of schopenhauer's opus
00:39:15  <bnoordhuis>what about you?
00:40:17  * elijah-mbpquit (Remote host closed the connection)
00:40:47  * elijah-mbpjoined
00:42:59  <piscisaureus_>we as in you and yourself?
00:45:20  <mmalecki>no, I believe Ben also took part in the discussion
00:46:14  <piscisaureus_>Would that refer to the representation of Ben or to Ben an sich?
00:48:33  * mikealquit (Quit: Leaving.)
00:57:31  * mikealjoined
01:01:06  <DrPizza>dunno if any of you guys saw, but win8 will (finally) make the built-in DNS API async
01:01:29  <DrPizza>currently it's sync with reserved parameters for overlapped mode (or callbacks, I forget which)
01:02:01  <piscisaureus_>DrPizza: yup, I saw
01:06:19  <CIA-99>node: Paul Vorbach v0.6 * rc1f4740 / doc/index.html :
01:06:20  <CIA-99>node: docs: fix quotation style in the webserver example
01:06:20  <CIA-99>node: Replace " by ' - http://git.io/F4Yekw
01:08:37  <bnoordhuis>http://hardware.slashdot.org/story/12/02/18/006200/stealing-laptops-for-class-credit <- my old uni
01:09:30  <mmalecki>now I know what bnoordhuis when he's not around
01:09:40  <mmalecki>* bnoordhuis does
01:10:24  <bnoordhuis>nowadays i only steal the hearts of young girls
01:10:40  <bnoordhuis>a messy affair, i must say
01:10:56  <mmalecki>this approach surely helps you: https://github.com/joyent/http-parser/pull/88#issuecomment-4030785
01:11:12  <bnoordhuis>damn right!
01:11:31  <bnoordhuis>you know what they say about girls
01:11:39  <bnoordhuis>"sometimes the mouth says 'no' but the eyes say 'yes'"
01:12:15  <mmalecki>that's why I always gag them!
01:13:06  <bnoordhuis>http://ask.slashdot.org/story/12/02/17/226256/ask-slashdot-life-after-software-development <- well, is there?
01:13:21  <bnoordhuis>maybe i'll become a carpenter some day
01:13:41  <bnoordhuis>that seems like a fulfilling job
01:13:43  <mmalecki>""I've been writing database apps for various industries" <- stopped reading after that
01:14:00  <bnoordhuis>hey, someone's gotta do it
01:14:07  * travis-cijoined
01:14:07  <travis-ci>[travis-ci] joyent/node#452 (v0.6 - c1f4740 : Paul Vorbach): The build was fixed.
01:14:07  <travis-ci>[travis-ci] Change view : https://github.com/joyent/node/compare/23c4278...c1f4740
01:14:07  <travis-ci>[travis-ci] Build details : http://travis-ci.org/joyent/node/builds/695222
01:14:07  * travis-cipart
01:14:55  <mmalecki>poor COBOL programmers
01:15:58  <bnoordhuis>mmalecki: so what are you going to do after the singularity?
01:16:45  <mmalecki>bnoordhuis: after http://en.wikipedia.org/wiki/Singularity_(operating_system)? dunno, kill myself?
01:16:57  <mmalecki>bnoordhuis: but no, what do you mean?
01:17:23  <bnoordhuis>mmalecki: after the singularity, computers won't need us humans anymore to program them
01:17:38  <bnoordhuis>so what's your second career going to be?
01:18:10  <mmalecki>bnoordhuis: I always secretly wanted to be a pharmacist
01:18:29  <bnoordhuis>mmalecki: i once dated a pharmacist's daughter, fun times
01:18:39  <mmalecki>which caused few problems back in the days
01:18:49  <mmalecki>lol
01:21:28  <bnoordhuis>piscisaureus_: what's your second career going to be?
01:21:43  <bnoordhuis>you make a pretty good coffee boy already
01:23:56  * pfox___quit (Ping timeout: 248 seconds)
01:25:14  <piscisaureus_>bnoordhuis: hitman
01:26:18  <bnoordhuis>piscisaureus_: can i get a group discount?
01:27:18  <piscisaureus_>You really need me to kill your mother in law?
01:35:53  * mikealquit (Quit: Leaving.)
01:39:04  <isaacs>bnoordhuis, piscisaureus_: so, i think this weekend i'd like to merge in 0.6 to master, and then fix all the lints.
01:39:16  <isaacs>it's time :)
01:41:43  <piscisaureus_>isaacs: sure, go ahead :-)
01:41:55  <piscisaureus_>isaacs: I won't be working on node until monday unfortunately
01:41:58  <isaacs>maybe move all failing tests into a group, too.
01:42:09  <piscisaureus_>I have to ramp up my university effort a little bit
01:42:19  <isaacs>yeah, you mentioned that yesterday.
01:42:20  <isaacs>that's fine.
01:42:37  <piscisaureus_>oh, good :-)
01:42:38  <isaacs>i've got a nice big block this weekend with nothing to do
01:42:49  <isaacs>not like you need my permission to keep up with school ;P
01:43:00  <piscisaureus_>isaacs: :-) indeed
01:43:19  <piscisaureus_>isaacs: I feel somewhat responsible for node
01:43:27  <isaacs>that's good!
01:44:04  <isaacs>i've got the start of a plan for the node modules website, too
01:44:25  <piscisaureus_>isaacs: you mean, npmjs.org v2.0
01:44:29  <piscisaureus_>or something else?
01:44:30  <isaacs>piscisaureus_: yessir
01:45:19  <isaacs>had a really good discussion wiht maxogden about the stuff that he and mikeal are using for their app. the framework they've built, and what he's done with datacouch, is remarkably similar to the npm use case.
01:47:06  <piscisaureus_>No picture comes to mind, but sounds like you have it sorted out :-)
01:47:30  <isaacs>sounds that way, right!?
01:50:10  <mmalecki>going to sleep. night!
01:50:17  <piscisaureus_>night mmalecki!
01:50:20  <piscisaureus_>I am also going
01:50:28  <piscisaureus_>bye all
01:50:31  <piscisaureus_>bnoordhuis: you too!
01:50:35  <mmalecki>bye!
01:50:46  * piscisaureus_quit (Quit: ~ Trillian Astra - www.trillian.im ~)
01:51:09  * mmaleckichanged nick to mmalecki[zzz]
01:57:57  * sj26_joined
01:58:10  * joclekjoined
01:59:56  * bnoordhuisquit (Ping timeout: 260 seconds)
02:03:28  * sj26quit (*.net *.split)
02:03:28  * jcequit (*.net *.split)
02:03:30  * sj26_changed nick to sj26
02:34:05  * TooTallNatequit (Quit: Linkinus - http://linkinus.com)
02:34:58  * dapquit (Quit: Leaving.)
03:02:53  * brsonquit (Quit: leaving)
03:35:44  * pfox___joined
04:06:04  * pfox___quit (Ping timeout: 248 seconds)
04:28:05  * mikealjoined
04:28:20  * benviejoined
04:49:54  * mikealquit (Quit: Leaving.)
04:52:56  * isaacsquit (Remote host closed the connection)
04:53:42  * isaacsjoined
04:57:27  * indutny_sleepingchanged nick to indutny
04:58:37  * isaacsquit (Ping timeout: 240 seconds)
05:02:07  <indutny>morning
05:02:59  * mikealjoined
05:17:37  * mikealquit (Quit: Leaving.)
05:23:16  * mikealjoined
05:28:36  * mikealquit (Quit: Leaving.)
05:32:00  * pfox___joined
05:43:56  * mikealjoined
05:45:39  * mikealquit (Client Quit)
05:51:52  * orlandovftwquit (Ping timeout: 252 seconds)
05:59:46  * pfox___quit (Ping timeout: 255 seconds)
06:52:26  * mjr_quit (Quit: mjr_)
07:20:21  * mikealjoined
07:26:42  * mikealquit (Quit: Leaving.)
08:21:16  * mikealjoined
08:22:01  * orlandovftwjoined
08:37:44  * paddybyersjoined
08:56:18  * paddybyers_joined
08:57:37  * paddybyersquit (Ping timeout: 240 seconds)
08:57:37  * paddybyers_changed nick to paddybyers
09:13:27  * orlandovftwquit (Ping timeout: 260 seconds)
09:45:26  * mralephjoined
10:03:23  * paddybyersquit (Quit: paddybyers)
10:25:38  * mraleph1joined
10:26:26  * mralephquit (Read error: Connection reset by peer)
11:17:39  * paddybyersjoined
11:20:57  * dshaw_quit (Quit: Leaving.)
11:21:53  * dshaw_joined
11:26:28  * paddybyersquit (Quit: paddybyers)
11:33:32  * dshaw_1joined
11:33:40  * dshaw_1quit (Client Quit)
11:35:44  * dshaw_quit (Ping timeout: 252 seconds)
11:48:46  * AndreasMadsenjoined
11:51:32  * paddybyersjoined
12:12:24  * paddybyersquit (Quit: paddybyers)
13:17:56  * bbenviejoined
13:49:08  * mmalecki[zzz]changed nick to mmalecki
13:49:19  <mmalecki>good morning!
13:49:32  <AndreasMadsen>mmalecki
13:49:38  <AndreasMadsen>morning
14:30:59  * AndreasMadsenquit (Remote host closed the connection)
14:35:37  * indutnyquit (Ping timeout: 240 seconds)
14:42:09  * mraleph1quit (Remote host closed the connection)
14:59:50  * AndreasMadsenjoined
15:06:28  * indutnyjoined
15:08:19  * isaacsjoined
15:30:37  * isaacsquit (Remote host closed the connection)
15:52:21  * pfox___joined
15:57:22  * piscisaureus_joined
15:57:26  <piscisaureus_>http://groups.google.com/group/nodejs/browse_thread/thread/ffd00d5213175428
15:57:29  <piscisaureus_>another one
15:57:31  <piscisaureus_>igorzi: ^
16:00:20  <pfox___>is there a way to stop/remove a uv_async_t ? or should i just uv_unref() it so the loop doesn't it, anymore, and move on?
16:00:29  <pfox___>doesn't count it, even
16:01:58  <piscisaureus_>pfox___: it should be counted. if it doesn't, that's a bug
16:02:24  <piscisaureus_>pfox___: you can close an uv_async with uv_close, just like any other handle
16:02:57  <pfox___>gotcha. thanks.
16:03:12  <piscisaureus_>pfox___: it is your own responsibility to make sure that you don't uv_async_send after you've called uv_async_close though
16:04:08  <pfox___>cool
16:04:08  <piscisaureus_>pfox___: btw - if you statically allocate the handle just unref()ing it is fine. But if you store the handle in malloc()ed memory you have to make sure that the handle is closed before you free that memory.
16:04:13  <piscisaureus_>basically just like any other handle
16:14:00  * pfox___quit (Ping timeout: 240 seconds)
16:21:58  * felixgejoined
16:21:58  * felixgequit (Changing host)
16:21:58  * felixgejoined
16:22:11  <felixge>piscisaureus_: send you a gist link on twitter
16:22:22  <piscisaureus_>felixge: saw that. thanks!
16:22:46  <felixge>piscisaureus_: headed out now for a swim, but would love to hear your findings via twitter, mail, or chat later
16:23:04  <piscisaureus_>felixge: will do. ttyl
16:23:13  <felixge>The main reason I'm doing this is to get a feel for the cost of different operations that I need in node-mysql.
16:23:30  <felixge>As I'm doing a refactoring of that and am curious how fast I could get it
16:23:31  <felixge>:)
16:23:40  <piscisaureus_>felixge: we should still do a pure-js benchmark for mysql. The v8 team is interested in benchmarks.
16:24:12  <felixge>piscisaureus_: yeah. But first of all I want to decide on the parsing technique I will use for the new parser.
16:24:26  <felixge>piscisaureus_: I'm not happy with the huge switch statement approach anymore
16:24:33  <piscisaureus_>:-_
16:24:35  <felixge>it's kind of a PITA
16:24:35  <felixge>:)
16:24:44  <piscisaureus_>The pain of state machines
16:24:59  <felixge>and it gets slower as you add states
16:25:15  <piscisaureus_>felixge: yeah. well, v8 should optimize them better
16:25:42  <felixge>well, I'm looking at different techniques now that will allow me split stuff into different abstraction levels
16:25:44  <piscisaureus_>felixge: it just generates a lot of compares and jumps right now
16:25:47  <felixge>Parser -> Element -> Packet
16:25:49  <felixge>something like this
16:25:55  <piscisaureus_>right
16:26:02  <felixge>so I can optimize individual Packets that are hot
16:26:07  <felixge>and not worry too much about the other stuff
16:26:11  <felixge>and have nicer code there instead
16:27:35  <felixge>and it would allow me to implement the hottest code in C very easily as well
16:27:37  <felixge>if I choose so
16:27:38  <felixge>not sure yet
16:27:39  <felixge>:)
16:27:44  <felixge>anyway, g2g, ttyl
16:28:35  * felixgequit (Quit: felixge)
16:48:14  * isaacsjoined
16:48:47  <piscisaureus_>felixge: http://screencast.com/t/ZeJxnsNdn <-- profiling report. AllocateStringFromUtf8Slow is very hot :-)
16:48:52  <piscisaureus_>The slow appears to be true
16:54:14  <einaros>hrm, profiling through vs. useful tip.
17:09:56  <piscisaureus_>I am under the impression the v8's utf8 performance is pretty pathetic
17:11:53  <mmalecki>piscisaureus_: wait, vs can generate reports like that?
17:12:03  <mmalecki>it's pretty... neat
17:12:04  <piscisaureus_>yes, of course
17:12:13  <piscisaureus_>windbg can generate even nicer reports
17:12:47  * mmaleckilooks for such a tool in Linux
17:13:50  <piscisaureus_>mmalecki: http://screencast.com/t/r8Mj1u9Z !
17:14:02  <indutny>gprof works fine for me too
17:14:13  <indutny>but app needs to be built with it's flag
17:14:13  <mmalecki>piscisaureus_: ok, I give up.
17:14:35  <indutny>piscisaureus_: oh
17:14:39  <indutny>piscisaureus_: is that win only?
17:14:56  <indutny>btw, cachegrind output looks interesting too ;)
17:15:01  <indutny>have you used cg_annotate?
17:15:03  <indutny>piscisaureus_: ^
17:18:37  * xaqjoined
17:18:44  <piscisaureus_>indutny: No, I never. I don't think it works on windows
17:18:46  <einaros>I should look around for msft employees, but in either regard; visual studio isn't suitable for much these days
17:19:33  <piscisaureus_>einaros: that sounds unwarranted
17:19:33  <indutny>piscisaureus_: heh
17:19:41  <indutny>piscisaureus_: you should try it on linux
17:19:45  <indutny>piscisaureus_: at list once
17:19:49  <piscisaureus_>yes, it works only on windows
17:19:52  <indutny>you'll fall in love with it, I promise you
17:19:58  <indutny>gtg
17:19:59  <indutny>ttyl
17:20:20  <einaros>piscisaureus_: well I've been using vs professionally since 97, and there has been a violent decline in performance all the way
17:20:52  <piscisaureus_>einaros: performance of what? VS itself? Generated code?
17:21:22  <einaros>at this point we're stuck with a inconsistent build system (msbuild vs visual studio builder) as well as a ui which gets more unstable by the month
17:21:26  <einaros>vs itself
17:21:33  <piscisaureus_>Oh
17:21:34  <mmalecki>managed to get node to startup ~0.7 ms faster, is it worth a pull request?
17:21:35  <einaros>the c++ compiler is good
17:21:37  <piscisaureus_>I never have problems with it]
17:21:57  <piscisaureus_>Actually, I quite like VS
17:22:03  <einaros>I have great respect for the compiler team, and used to work extensively with them
17:22:25  <einaros>but vs itself, since switching to xaml for some of the ui, has become a pita
17:22:34  <piscisaureus_>And with gyp it isn't really a problem. Msbuild just builds the vcxproj files
17:22:45  <piscisaureus_>Oh, well, I don't use gui tools
17:22:48  <piscisaureus_>just the editor
17:22:50  <tjfontaine>what's a gui?
17:22:56  <einaros>and large projects (500k loc up) is slow as fudge
17:23:31  <mmalecki>tjfontaine: I think that's what hipster kids use these days to slow computers down
17:23:41  <einaros>working on large enterprisey systems is a pita in visual studio
17:23:54  <einaros>working on small hobby-kind-of-projects, not so much
17:24:07  <mmalecki>working on large enterprisey systems is a pita :)
17:24:08  <tjfontaine>mmalecki: is it related to this mouse thing attached to my computer?
17:24:11  <einaros>the non-native test runner in vs is a joke
17:24:22  <einaros>mmalecki: sure, but that's how most of still make a living
17:24:56  <einaros>in either regard, this has nothing to do with node, so I'll quiet down now
17:24:58  <mmalecki>tjfontaine: yeah, I think so? I throwed it away to get more space for my third keyboard
17:25:38  <tjfontaine>:)
17:28:32  <mmalecki>turns out there's Instruments app for macs, which does all sort of profiling
17:30:10  <einaros>ws is long overdue a proper profiling run, with video streaming and RTC coming at any point now
17:32:03  * diogosnowsjoined
17:32:17  <einaros>at this point it is easily 50% faster than other libraries on node, but still 100% slower than the fastest C libraries. it should be possible to push that further.
17:33:45  * elijah-m_joined
17:35:43  * indutny_joined
17:36:36  * mikeal1joined
17:37:41  * sj26quit (Ping timeout: 240 seconds)
17:37:41  * indutnyquit (Ping timeout: 240 seconds)
17:37:42  * mikealquit (Ping timeout: 240 seconds)
17:37:42  * elijah-mbpquit (Ping timeout: 240 seconds)
17:38:00  * sj26joined
17:38:11  <AndreasMadsen>autch
17:38:30  * isaacsquit (Remote host closed the connection)
17:38:56  * isaacsjoined
17:39:58  * paddybyersjoined
17:52:52  * elijah-m_changed nick to elijah-mbp
18:15:09  * pfox___joined
18:15:44  * paddybyersquit (Quit: paddybyers)
18:16:29  <CIA-99>node: Paul Vorbach master * rc1f4740 / doc/index.html :
18:16:30  <CIA-99>node: docs: fix quotation style in the webserver example
18:16:30  <CIA-99>node: Replace " by ' - http://git.io/F4Yekw
18:16:31  <CIA-99>node: isaacs master * r31721da / (28 files in 12 dirs): (log message trimmed)
18:16:31  <CIA-99>node: Merge remote-tracking branch 'ry/v0.6' into v0.6-merge
18:16:31  <CIA-99>node: Conflicts:
18:16:31  <CIA-99>node: AUTHORS
18:16:32  <CIA-99>node: ChangeLog
18:16:32  <CIA-99>node: Makefile
18:16:33  <CIA-99>node: doc/about/index.html
18:19:13  * felixgejoined
18:19:13  * felixgequit (Changing host)
18:19:13  * felixgejoined
18:21:50  * felixgequit (Client Quit)
18:24:08  * mikeal1quit (Quit: Leaving.)
18:25:52  * TooTallNatejoined
18:29:06  * orlandovftwjoined
18:30:36  * travis-cijoined
18:30:36  <travis-ci>[travis-ci] joyent/node#453 (master - 31721da : isaacs): The build is still failing.
18:30:36  <travis-ci>[travis-ci] Change view : https://github.com/joyent/node/compare/0787287...31721da
18:30:36  <travis-ci>[travis-ci] Build details : http://travis-ci.org/joyent/node/builds/697984
18:30:36  * travis-cipart
18:35:33  * orlandovftwquit (Ping timeout: 260 seconds)
18:47:11  * orlandovftwjoined
18:48:36  <mmalecki>hey, I have this branch, making node startup ~0.7 ms faster on my computer, is it worth pull requesting? https://github.com/mmalecki/node/compare/speed-up-startup
18:51:37  * mikealjoined
18:52:23  * diogosnowsquit (Ping timeout: 252 seconds)
18:52:26  <indutny_>0.7ms :D
18:52:40  <indutny_>sorry, but I've a stronge urge of trolling
18:52:43  <mmalecki>well, it's totally measurable!
18:52:49  <mmalecki>lol
18:52:53  <indutny_>haha
18:53:12  <indutny_>I'll try to mitigate it :D
18:53:31  <mmalecki>:D
18:53:48  <mmalecki>but no, really, fetch it and try the startup bechmark
18:53:55  <mmalecki>*benchmark
18:54:29  <indutny_>yeah, I trust you
18:54:35  <indutny_>probably we'll pull that
18:54:39  <indutny_>but anyway that looks funny :D
18:55:02  <mmalecki>I MEAN, 0.7!
18:55:19  <indutny_>f*ck, I can't mitigate it
18:55:30  * isaacsquit (Remote host closed the connection)
18:55:33  <indutny_>"I made your executable ~0.7 bytes smaller"
18:55:48  <mmalecki>lol
18:56:20  <mmalecki>that reminds me, I'll go and check load balancers now
18:56:25  <mmalecki>er, not here
18:56:56  <indutny_>heh
18:56:57  <indutny_>yeah
18:57:01  <indutny_>not here
18:57:08  * indutny_goes to shower, and the is going to sleep
18:57:19  <mmalecki>night Fedor!
18:57:26  <indutny_>you too
19:00:35  * indutny_changed nick to indutny_sleeping
19:09:58  * mikealquit (Quit: Leaving.)
19:26:50  <AndreasMadsen>mmalecki: what was EventEmitter assigned to before "var keyword" commit.
19:27:43  <mmalecki>AndreasMadsen: the same thing, I just moved declaration up
19:28:44  <AndreasMadsen>mmalecki: so process.EventEmitter = EventEmitter was not required before the commit?
19:29:16  <mmalecki>AndreasMadsen: it was? take a look at the current code
19:29:59  <AndreasMadsen>mmalecki: oh, hehe I see :D
19:34:46  <AndreasMadsen>mmalecki: yeah make the pull request, I should make more small patches too.
19:36:53  * orlandovftwquit (Ping timeout: 276 seconds)
19:50:00  * AvianFluquit (Ping timeout: 240 seconds)
19:50:48  * AvianFlujoined
19:56:01  <TooTallNate>EWRITTENINCOFFESCRIPTREFUSINGTOUSE
19:56:27  <tjfontaine>heh, language bigot :)
19:56:33  <AvianFlu>TooTallNate, ++
19:56:34  <kohai>TooTallNate has 3 beers
19:56:37  <mmalecki>TooTallNate: ++
19:56:37  <kohai>TooTallNate has 4 beers
19:57:09  <TooTallNate>lulz, wrong room :O
19:57:24  <mmalecki>got beers anyway!
19:58:41  <TooTallNate>yup :)
20:13:23  * brsonjoined
20:17:20  * isaacsjoined
20:19:28  <isaacs>mmalecki: hey, the var EventEmitter... isn't that being used in other functions?
20:19:41  <AndreasMadsen>no
20:19:42  <mmalecki>isaacs: nope. let me double check
20:19:50  <isaacs>mmalecki: oh, ok, maybe it used to be.
20:20:00  <isaacs>if it's not, then the way you're doing it is totally right
20:20:09  <mmalecki>isaacs: I know :)
20:20:31  <isaacs>getting cwd is actually on purpose, i believe
20:20:54  <isaacs>mmalecki: because we *want* to blow up immediately if you're in a cwd that's been deleted.
20:21:00  <isaacs>rather than later on
20:21:34  <mmalecki>isaacs: does uv/node blow there? I've seen some discussion about this and I don't actually remember what does it do
20:21:44  <isaacs>and, we want to blow up on invalid cwd even if the path is absolute
20:22:05  <isaacs>also, should be just `path.resolve(argv[0])`
20:22:26  <isaacs>path.resolve() returns an absolute path, joined against cwd if necessary
20:23:57  <mmalecki>isaacs: I see. moving process.cwd() isn't actually any seenable performance gain, so.
20:24:31  <isaacs>mmalecki: but, we could replace that whole if (absolute) path.join(cwd) bit with `argv[0] = path.resolve(argv[0]);'
20:34:56  <mmalecki>isaacs: good point, will it work on windows too?
20:44:22  * paddybyersjoined
20:46:12  <piscisaureus_>yes
20:48:33  <piscisaureus_>Merge remote-tracking branch 'ry/v0.6' into v0.6-merge
20:48:38  <AvianFlu>piscisaureus_, isaacs, I made a first-pass implementation of a --daemonize flag for node
20:48:38  <AvianFlu>https://github.com/AvianFlu/node/commit/94e6a4707f2b7eec7421f3709e2e58f80ee300a5
20:48:48  <AvianFlu>all comments appreciated - and I've got no idea how to do it on windows
20:50:35  <isaacs>piscisaureus_: :)
20:50:57  <isaacs>piscisaureus_: was pretty easy. only potential hazard is the tls stuff, but the tests all pass, so i think i got it right.
20:51:05  * isaacsis now a lint machine.
20:51:32  <piscisaureus_>isaacs: oh, right. I was just commenting on the log message, it looks outdated :-)
20:51:45  <piscisaureus_>ry/node man, that's > a yar ago
20:51:48  <piscisaureus_>*year
20:52:08  <isaacs>piscisaureus_: yeah, but muscle memory dies hard.
20:52:22  <isaacs>ry git://github.com/joyent/node (push)
20:52:23  <isaacs>ry git://github.com/joyent/node (fetch)
20:52:23  <isaacs>ry-push git@github.com:joyent/node.git (push)
20:52:24  <isaacs>ry-push git@github.com:joyent/node.git (fetch)
20:52:31  <piscisaureus_>ghe
20:52:55  <piscisaureus_>AvianFlu: cool. I don't know enough about unix to really judge it. I think bnoordhuis should review it.
20:53:19  <piscisaureus_>AvianFlu: one question, does stdout and -err always need to be redirected to /dev/null?
20:53:29  <AvianFlu>piscisaureus_, that's an open question for me as well
20:53:33  <piscisaureus_>AvianFlu: what if, for example, an user sets up a redirect to a file?
20:53:39  <AvianFlu>as far as this prototype is concerned, I figured leave logging to loggers
20:53:46  <AvianFlu>but it's a good point
20:54:16  <AvianFlu>could make it configurable, but I wasn't sure how it should work
20:54:33  <piscisaureus_>that's where I want bnoordhuis to weigh in
20:54:45  <piscisaureus_>because I don't really know how that should work either
20:54:51  <TooTallNate>shouldn't that go into libuv?
20:55:20  <piscisaureus_>I think that would be best yes
20:55:26  <piscisaureus_>but prototyping in node is fine
20:56:02  <AvianFlu>it was also a whole lot easier to decide where to put it in node.cc instead of libuv :D
20:56:49  <mmalecki>AvianFlu: ++
20:56:49  <kohai>AvianFlu has 69 internet points
20:57:02  <mmalecki>ideally it'd go to libuv and handle windows as well
20:57:11  <AvianFlu>yeah, definitely
20:57:49  <isaacs>so torn on this.
20:59:01  <mmalecki>isaacs: no more nodejitsu people complaining about fork not working!
20:59:02  <piscisaureus_>isaacs: on what?
20:59:12  <isaacs>piscisaureus_: on --daemonize for node.
20:59:20  <piscisaureus_>isaacs: why?
20:59:20  <isaacs>ie, being in node core
20:59:46  <isaacs>seems kinda weird as a command-line flag.
20:59:59  <isaacs>like, if we were going to do this, why not have a process.daemonize() function?
21:00:17  <piscisaureus_>isaacs: because I told them not to do that
21:00:21  <isaacs>haha :)
21:00:27  <AvianFlu>well, it has to happen before there's an active thread pool, or fork() won't cooperate
21:00:27  <piscisaureus_>isaacs: daemonize() requires fork() on unix
21:00:34  <isaacs>hm...
21:00:36  <AvianFlu>that's one of the primary reasons it's hard in userland
21:00:45  <piscisaureus_>Well
21:00:51  <isaacs>i see, so it has to happen before it gets to the thread pool.
21:00:51  <piscisaureus_>I don't really agree that it is hard
21:01:03  <piscisaureus_>you would just have to write your own small wrapper
21:01:21  <piscisaureus_>like, noded
21:01:31  <isaacs>piscisaureus_: right, that that IS a big deviation from the standard module story
21:01:35  <piscisaureus_>which forks(), dup2() and then exec('node')
21:01:38  <isaacs>so, not hard, but certainly weird.
21:02:17  <piscisaureus_>yes
21:02:24  <mmalecki>can't we have uv_default_fork() which would magically take care of about thread pool?
21:02:28  <piscisaureus_>otoh, you could probably do it in a bash script :-)
21:02:52  <mmalecki>as far as I understand, it'd have to spin up the threads again?
21:03:03  <isaacs>right
21:03:16  <isaacs>why not just have a bash script that wraps node?
21:04:45  <mmalecki>uhm, how can we fork in bash?
21:06:09  <piscisaureus_>node script.js 0</dev/null 1>/dev/null 2>/tmp/any.out & ?
21:06:17  <piscisaureus_>nohup node script.js 0</dev/null 1>/dev/null 2>/tmp/any.out & ?
21:06:37  <AvianFlu>piscisaureus_, that process is still a child of your terminal session when you do that, I believe
21:07:04  <piscisaureus_>AvianFlu: not if you do it in a bash script
21:07:11  <AvianFlu>I've got a little tool I wrote in C that will daemonize random things properly, but the idea of trying to ship it with forever just isn't fun
21:07:14  <piscisaureus_>as soon as `sh` dies it will be parented to init
21:07:24  <AvianFlu>yeah, that's tru
21:07:24  <AvianFlu>e
21:07:46  <mmalecki>that's true, we can nohup, but nohup doesn't work on windows
21:08:06  <piscisaureus_>mmalecki: on windows, you do `start node script.js` :-)
21:08:48  <piscisaureus_>mmalecki: ok, that's not completely true as it will still show a console
21:08:53  <piscisaureus_>but that's something we can fix
21:08:58  * felixgejoined
21:08:58  * felixgequit (Changing host)
21:08:58  * felixgejoined
21:09:07  * leifjoined
21:09:47  * ljacksonquit (Ping timeout: 260 seconds)
21:09:47  * pquernaquit (Ping timeout: 260 seconds)
21:09:53  * pquernajoined
21:12:07  * piscisaureus_quit (Quit: ~ Trillian Astra - www.trillian.im ~)
21:12:47  * paddybyersquit (Quit: paddybyers)
21:15:54  * felixgequit (Quit: felixge)
21:19:52  * bnoordhuisjoined
21:20:05  * felixgejoined
21:20:05  * felixgequit (Changing host)
21:20:05  * felixgejoined
21:20:07  * piscisaureus_joined
21:20:15  * felixgequit (Client Quit)
21:20:26  <piscisaureus_>isaacs: AvianFlu: mmalecki: we could also add an option to child_process.spawn that daemonizes()
21:20:33  <piscisaureus_>that would be really easy on either OS
21:20:42  <piscisaureus_>on unix, you fork() twice
21:20:49  <piscisaureus_>on windows we set the DETACHED_PROCESS option
21:21:02  <isaacs>piscisaureus_: that would be nice.
21:21:10  <AvianFlu>yeah, that would work on our end too
21:21:11  <mmalecki>piscisaureus_: would it still emit 'exit' events and such?
21:21:25  <isaacs>i don't really like adding new cli args to node, since now those are arguments that can't easily be passed to node programs.
21:21:29  <piscisaureus_>mmalecki: nope. It would emit exit immediately after forking
21:21:43  <isaacs>unless it's an explicit switch to turn some functionality on or off
21:21:56  <mmalecki>piscisaureus_: but parent process would stay alive in the foreground?
21:22:03  <isaacs>mmalecki: not if it's daemonized.
21:22:09  <isaacs>it'd be a detached process.
21:22:21  <isaacs>like ^Z, bg, detach in bash
21:22:24  <piscisaureus_>mmalecki: the current node process stays alive. The child process will be completely detached from the parent
21:22:37  <isaacs>piscisaureus_: so then the child won't keep the parent alive, correct?
21:22:46  <piscisaureus_>indeed
21:23:02  <isaacs>yeah, child_process.spawn(cmd, [args], {daemonize: true}) would be ideal.
21:23:18  <isaacs>that's the correct api for this, imo.
21:23:22  <piscisaureus_>isaacs: so probably we should name it "detached"
21:23:28  <isaacs>oh, right.
21:23:31  <isaacs>yeah, agreed.
21:23:42  <isaacs>child_process.spawn(cmd, [args], {detached: true})
21:23:42  <piscisaureus_>isaacs: since to correctly demonize you also have to disassociate from the current console.
21:23:49  <piscisaureus_>er, tty :-)
21:24:00  <isaacs>child_process.spawn(cmd, [args], {detached: true, stdio: 'null'})
21:24:07  <piscisaureus_>yes
21:24:27  <piscisaureus_>I don't really know whether other activities would be necessary, e.g. setgid etc
21:24:33  * hij1nx_joined
21:24:53  <isaacs>child_process.spawn(cmd, [args], {detached: true, stdio: 'null', setsid: true, gid: 'nobody', uid: 'nobody'})
21:24:53  <piscisaureus_>or, setsid, umask, whatever funny unix apis there are
21:24:56  <isaacs>right
21:25:08  <tjfontaine>dropping privs would be ideal
21:25:09  <isaacs>oh, i think uid/gid have to be ints, not names.
21:25:17  <mmalecki>yeah, ints
21:25:18  <AvianFlu>yeah, they do
21:25:19  <isaacs>but that's actually somewhat separate from daemonizing.
21:25:32  <isaacs>quite often you *do* want to have a daemon running as root for various reasons.
21:25:58  <tjfontaine>I don't know about often
21:26:37  <isaacs>sure, but sometimes.
21:26:40  * `3rdEdenjoined
21:27:03  <isaacs>but like, if we have a node daemon that runs in the global zone of a smartos box, and sets up zones for people, taht's going to need root privs.
21:27:20  <isaacs>or at least, privs to do that one action, since smartos has granular permissions
21:27:38  <mmalecki>so, is process.daemonize() a go/no-go?
21:27:43  <tjfontaine>1/2 the goal of dropping privs is usually because you want to bind to < 1024, which can be solved with other things like authbind
21:28:12  <piscisaureus_>isaacs: so the thing is that I don't know what all these setgid/uid, setsid, umask etc are used for
21:28:12  <tjfontaine>isaacs: ya, I think the reasons for keeping things around as root are growing fewer and fewer
21:28:29  <piscisaureus_>isaacs: someone would have to write it down so I can see how that maps to windows conceps
21:28:32  <piscisaureus_>*concepts
21:28:40  * paddybyersjoined
21:29:13  <tjfontaine>umask effects the default modes for file and directory creation, in a nut shell
21:29:39  <AvianFlu>and setsid() starts a new process group with the current process as the parent
21:29:39  <piscisaureus_>that's probably not releavnt
21:29:41  <piscisaureus_>*relevant
21:29:52  <tjfontaine>022 for instance, subtracts from the default of 666 resulting in 644, or 777 to 755
21:30:13  <piscisaureus_>On windows we have this http://msdn.microsoft.com/en-us/library/windows/desktop/ms682429%28v=vs.85%29.aspx which may or may not be related to setuid/gid
21:31:52  <mmalecki>would it be possible to have fork with daemonize?
21:32:22  <AvianFlu>mmalecki, child_process.fork() you mean?
21:32:25  * `3rdEdenquit (Quit: Linkinus - http://linkinus.com)
21:32:38  <piscisaureus_>mmalecki: yes
21:33:05  <mmalecki>AvianFlu: yeah, that
21:34:18  <isaacs>tjfontaine: it's not subtraction, exactly. it's bitwise masking.
21:34:24  <mmalecki>ok, so let's go and implement it.
21:34:38  <isaacs>umask is probably not important for windows, i'd think.
21:34:41  <mmalecki>AvianFlu: want to...?
21:34:46  <isaacs>but setuid/gid would be nice.
21:35:03  <AvianFlu>mmalecki, yes.
21:35:12  <mmalecki>AvianFlu: sounds great!
21:35:22  <isaacs>piscisaureus_, mmalecki: wait, how could you have fork() if you don't have the stdio in the child?
21:35:35  <isaacs>i mean, you could with a *detached* process, sure.
21:35:44  <isaacs>but *daemonize* is explicitly "no connection, even stdio)
21:36:02  <piscisaureus_>isaacs: well, yeah, so you could do it with detached
21:36:19  <isaacs>but if stdio: 'null' is set for cp.fork() then we've got problems
21:37:33  <CIA-99>node: Ben Noordhuis v0.6 * r96a137a / doc/node.1 : docs: update man page - http://git.io/idp6ug
21:38:05  * leifquit (Read error: Operation timed out)
21:39:50  <piscisaureus_>isaacs: yes, then it won't work :-)
21:42:42  <isaacs>oh, man... test/simple/test-crypto.js
21:42:44  <isaacs>jesus.
21:42:53  * isaacssummoning mighty vim macros
21:43:29  <mmalecki>there are vim macros for linting :o ?
21:43:36  <mmalecki>DO WANT.
21:45:22  * travis-cijoined
21:45:22  <travis-ci>[travis-ci] joyent/node#454 (v0.6 - 96a137a : Ben Noordhuis): The build passed.
21:45:22  <travis-ci>[travis-ci] Change view : https://github.com/joyent/node/compare/c1f4740...96a137a
21:45:22  <travis-ci>[travis-ci] Build details : http://travis-ci.org/joyent/node/builds/698928
21:45:22  * travis-cipart
21:45:43  <piscisaureus_>ok, i quit
21:45:45  <piscisaureus_>bye all
21:45:49  <mmalecki>bye piscisaureus_
21:45:58  * piscisaureus_quit (Quit: ~ Trillian Astra - www.trillian.im ~)
21:50:39  * hij1nx_quit (Quit: hij1nx_)
21:52:44  * leifjoined
22:05:09  <bnoordhuis>isaacs: https://github.com/joyent/node/issues/2736#issuecomment-4034801 <- i don't see the bug
22:05:42  * paddybyersquit (Quit: paddybyers)
22:06:00  <bnoordhuis>is it that it should be encoded to dXNlciUzQWZvb0A6YmFy?
22:12:13  * pfox___quit (Ping timeout: 252 seconds)
22:19:33  * pfox___joined
22:19:51  * AndreasMadsenquit (Remote host closed the connection)
22:24:10  <isaacs>bnoordhuis: if you do http.request(url.parse('http://user%3Afoo%40:bar@localhost:8000/')) *without* your patch, you get the wrong Authorization header.
22:25:08  <isaacs>bnoordhuis: it'll send base64('user%3Afoo%40:bar') instead of base64('user:foo@:bar')
22:31:40  <bnoordhuis>isaacs: ack
22:36:19  * toothrquit (Quit: here we are)
22:37:50  <isaacs>bnoordhuis: iow, your patch lgtm. a test of http.get(url.parse(funkyStuff)) would be +97 extra credit points, though.
22:46:16  <bnoordhuis>isaacs: sure, i'll add one
22:46:21  * toothrjoined
22:48:49  <isaacs>btw, i'm in the middle of linting.
22:49:28  <isaacs>bnoordhuis: it is so contrary to my esthetic, this thing.
22:49:55  <bnoordhuis>yeah, i'm not a fan either
22:50:17  * pfox___quit (Ping timeout: 245 seconds)
22:50:17  <mmalecki>isaacs: don't do it?
22:50:27  <mmalecki>I don't think people actually care much
22:51:06  <isaacs>mmalecki: we need a consistent style. if lint doesn't pass, then we may as well not lint, and there are too many hands on node for that to be a reasonable option.
22:52:16  <mmalecki>isaacs: there's this thing, "common sense". people should learn to use it without using tools.
22:52:21  <isaacs>the value of consistency is greater than any one person's esthetic.
22:52:45  <bnoordhuis>if lint doesn't pass, then we may as well not lint <- sounds good to me
22:53:11  <isaacs>maintaining consistency in a codebase can be done either by having very few contributors, or by using a tool.
22:53:13  <mmalecki>isaacs: well, we've no problems with maintaining consistency in our codebase and it's much bigger than node's codebase is.
22:53:25  <mmalecki>isaacs: also, we've more contributors :)
22:53:35  <isaacs>mmalecki: which codebase is this?
22:53:39  <mmalecki>isaacs: nodejitsu
22:53:51  <AvianFlu>mmalecki, we jshint everything, that's the same kind of thing
22:53:57  <AvianFlu>we have company-wide style guides
22:53:57  <mmalecki>AvianFlu: do you?
22:53:58  <isaacs>it has more people contributing to it than node does? that sounds dubious.
22:54:04  <isaacs>also, you do have a tool.
22:54:13  <AvianFlu>mmalecki, vim does it now, thanks to you
22:54:25  <AvianFlu>and we definitely don't have more contributors
22:54:27  <mmalecki>AvianFlu: I ignore what vim tells me, unless it's *real*
22:54:48  <AvianFlu>well yeah, there are a few stupid things that should be exceptions sometimes
22:54:51  <mmalecki>AvianFlu: like, out of scope variable usage
22:55:04  <bnoordhuis>git shortlog -ns | wc -l
22:55:04  <bnoordhuis>297
22:55:07  <mmalecki>actually, I'll fix this out of scope variable usage I'm talking about right now
22:55:19  <bnoordhuis>what about you, nodejitsu guys?
22:55:23  <mmalecki>and we've more commiters, should've clarified it
22:55:30  <bnoordhuis>ah!
22:55:32  <mmalecki>bnoordhuis: what's this?
22:55:56  <bnoordhuis>mmalecki: this is a context-sensitive javascript object
22:56:15  <AvianFlu>ahahhahaha
22:56:19  <mmalecki>bnoordhuis: ah, I see what it does
22:57:16  <isaacs>committers are much more dangerous than contributors :)
22:57:26  <isaacs>*especially* without a tool to keep us in line.
22:57:41  <bnoordhuis>oh, don't worry about that - tools never stopped me before
22:58:38  <mmalecki>bnoordhuis: ++
22:58:38  <kohai>bnoordhuis has 7 beers
22:59:39  <mmalecki>I mean, I hate being that guy, but it makes no sense
22:59:54  <mmalecki>number of people running jslint after every patch will be minimal
23:00:02  <bbenvie>I came up with a really cool way to crash node. Attempting to share v8 handles across node processes via the windows clipboard
23:00:17  <isaacs>mmalecki: step 2 is that we add it to make test, and make the tests all pass.
23:00:23  <bbenvie>it works exactly as well as it sounds like it would
23:00:42  <isaacs>mmalecki: and all tests pass all the time.
23:00:52  <mmalecki>isaacs: that's a good idea
23:01:07  <mmalecki>I can try to dig into this http test
23:01:15  <mmalecki>when I find some free cycles :/
23:01:23  <isaacs>$ make jslint
23:01:23  <isaacs>PYTHONPATH=tools/closure_linter/ python tools/closure_linter/closure_linter/gjslint.py --unix_mode --strict --nojsdoc -r lib/ -r src/ -r test/ --exclude_files lib/punycode.js
23:01:23  <isaacs>Skipping 1 file(s).
23:01:25  <isaacs>522 files checked, no errors found.
23:01:27  <isaacs>fuck yeah.
23:02:38  <mmalecki>ECODELOOKSAWFULNOW.
23:03:10  <bnoordhuis>that's what i'm kind of worried about
23:03:45  <bnoordhuis>test-crypto for example won't pass jslint as-is, but linted it looks hideous
23:03:50  <isaacs>it's actually mostly in line with what vim does by default.
23:03:59  <isaacs>bnoordhuis: i just split the strings into chunks. it's not that bad, really.
23:04:11  <isaacs>but, linting tests is probably not something we'll want to do all the time. it's too slow.
23:04:22  <isaacs>plus, we're in them less.
23:04:34  <bnoordhuis>speak for yourself, isaacs :)
23:04:47  <isaacs>what i mean is, we add to tests, we don't typically go messing with tjem.
23:05:03  <isaacs>but *any* chnage to functionality changes what's in src/ and lib/
23:05:15  <isaacs>so the value of linting that every time is higher.
23:05:52  <isaacs>it's like 5s vs 20s.
23:07:05  <bnoordhuis>i wonder... does it lint in parallel?
23:07:20  <bnoordhuis>if not, obvious optimization is obvious
23:07:39  <isaacs>yeah, i'm pretty sure it doesn't.
23:07:48  <mmalecki>no, it's too important to be done in parallel. higher possibility of data corruption.
23:08:00  <isaacs>mmalecki: hahah
23:13:59  <mmalecki>bnoordhuis: also, pretty sure that's because python's threading model is retarded and it's multiprocessing model is even more retarded
23:14:30  <bnoordhuis>mmalecki: there's always fork
23:14:33  <bnoordhuis>in python anyway :)
23:14:40  <mmalecki>hah :)
23:14:51  <bnoordhuis>threads in python are a lost cause
23:14:55  <bnoordhuis>unless you're using jython
23:15:04  <mmalecki>jython is a lost cause
23:15:20  <mmalecki>wondering how did they do that in pypy
23:15:43  <bnoordhuis>with a lot of complexity
23:16:09  <bnoordhuis>actually, i don't know - they've switched threading models more than once, i believe
23:16:26  <mmalecki>they've mentioned getting rid of GIL
23:16:52  <bnoordhuis>http://doc.pypy.org/en/latest/faq.html#does-pypy-have-a-gil-why
23:16:59  <bnoordhuis>tldr; yes
23:17:10  <mmalecki>http://morepypy.blogspot.com/2011/06/global-interpreter-lock-or-how-to-kill.html
23:17:24  <mmalecki>oh well :)
23:17:43  <bnoordhuis>yeah, stm... i hope it works out for them
23:18:30  <mmalecki>I guess I never actually liked threads :)
23:18:51  <bnoordhuis>threads have their time and place
23:19:10  <bnoordhuis>but for lots of things you're better off with either an event loop or separate processes
23:19:10  <mmalecki>'80s?
23:19:15  <bnoordhuis>heh
23:20:09  <mmalecki>I mean, there *are* runtimes which managed to drop threads and became fast as hell at doing *some* operations with them
23:20:59  <mmalecki>but in most cases threads are a terrible fail, especially with I/O (not with libuv model tho)
23:21:54  <bnoordhuis>oh, file i/o still sucks big time in libuv
23:22:02  <bnoordhuis>because it's all done in the thread pool
23:22:27  * bnoordhuiswishes on a star for true AIO
23:22:33  <mmalecki>yeah :). wondering if switching to "native" asynchronous operations would make it much faster?
23:23:22  <bnoordhuis>not quite
23:23:29  <bnoordhuis>unices don't have true native AIO
23:23:37  <bnoordhuis>well, maybe solaris
23:23:53  <bnoordhuis>but the linux kernel API is async until it's not
23:23:57  <bnoordhuis>and it won't tell you :/
23:24:14  <bnoordhuis>it also only works with files opened in O_DIRECT mode
23:24:53  <mmalecki>I see. why does it become synchronous at some point?
23:27:27  <bnoordhuis>mmalecki: not all file systems support AIO
23:27:49  <bnoordhuis>also, if you forget to open the file with O_DIRECT, you don't get an error, it just silently defaults to sync i/o
23:27:51  <mmalecki>bnoordhuis: oh, right. so no way to perform a check?
23:27:58  <bnoordhuis>alas, no
23:28:16  <mmalecki>lame.
23:28:21  <bnoordhuis>yes
23:28:39  <bnoordhuis>if i ever have three to six months to kill, i'm going to fix it
23:28:52  <tjfontaine>aio works on the common file systems
23:29:02  <mmalecki>so, like, let's write our own OS, would we?
23:29:15  <bnoordhuis>tjfontaine: yes, but that's not good enough
23:29:25  * paddybyersjoined
23:29:33  * pfox___joined
23:29:36  <bnoordhuis>mmalecki: you should talk to ryan and bert :)
23:29:44  <mmalecki>bnoordhuis: oh?
23:29:45  <tjfontaine>sure I understand that, but the folks who run things that are not in (ext, xfs, jfs) can go jump in a lake anyway :)
23:29:58  <mmalecki>bnoordhuis: are they writing some OS?
23:30:10  <bnoordhuis>mmalecki: they want to at least
23:30:40  <mmalecki>bnoordhuis: I don't even mind spending 3 months on it, if they promise it's fun!
23:30:46  <mmalecki>it actually is.
23:30:52  <bnoordhuis>tjfontaine: i kind of agree but a "mostly async" approach wouldn't be acceptable for node
23:30:54  <mmalecki>except that time when I forgot to align pages
23:31:06  <mmalecki>it was kinda fail
23:31:20  <bnoordhuis>you told me about that
23:31:38  <bnoordhuis>remind me, was it a unix clone?
23:31:44  <mmalecki>yeah
23:31:52  <tjfontaine>clearly what we all want is plan9
23:31:56  <mmalecki>it was supposed to be, at least :)
23:32:00  <bnoordhuis>hah, that's what i told bert
23:32:06  <mmalecki>bnoordhuis: you can look at the code here https://github.com/mmalecki/cOS
23:32:09  <bnoordhuis>mmalecki: join the club :)
23:32:22  <mmalecki>bnoordhuis: but well, dragons and shit. better watch out
23:33:41  <bnoordhuis>tjfontaine: actually, plan9 does a lot of things right
23:33:49  <tjfontaine>I know
23:33:58  <bnoordhuis>except for that usability and backwards compatibility thing
23:34:09  <tjfontaine>that's why I said it and not something like beos :)
23:34:38  <mmalecki>I have a nerd crush on haiku, tho
23:35:03  <bnoordhuis>tjfontaine: i was discussing a plan9 port of libuv with bert this week
23:35:14  <bnoordhuis>admittedly we were both quite drunk
23:35:16  <bnoordhuis>but still
23:35:24  <tjfontaine>hehe
23:35:57  <bbenvie>mozilla's doing their servo thing and google has chrome os, now's a good time to be in the os making business
23:36:32  <tjfontaine>start with genode, it's an os toolkit
23:37:30  <pfox___>im working on the rust port, atm
23:37:34  <bnoordhuis>https://github.com/chovy <- check out this guy
23:37:39  <pfox___>it's good fun
23:37:40  <bnoordhuis>especially the number of people he's following
23:37:52  <pfox___>on *a* rust port, i should say.
23:38:19  <bnoordhuis>pfox___: i was about to mention that the rust guys themselves are working on it too
23:38:32  <pfox___>yeah. just in the last week we got c->rust FFI
23:38:40  <bnoordhuis>yeah, exactly
23:38:43  <pfox___>and that makes a general-purpose, threadsafe rust binding possible
23:38:57  <pfox___>they were doing some narrow-use stuff w/ libuv already, using lots of hacky port/chan communication
23:39:10  <pfox___>and my impl still have that. but originating calls from within the libuv thread is important
23:39:55  <bnoordhuis>that c to rust bridge is a good thing
23:40:05  <bbenvie>yeah rust is part of servo. I think that's what it's being called anyway
23:40:11  <bnoordhuis>once i figure out how to link to a static lib, i'm going to finish my http-parser bindings
23:40:23  <pfox___>rust is the impl lang/runtime for servo
23:40:34  <bbenvie>yeah
23:40:52  <bbenvie>with js being most of what will be on top of that or so I've hjeard
23:41:37  <bbenvie>going all the way with things like dom.js, pdf.js, and flash.js
23:41:38  <pfox___>i know one of the guys who is a core rust committer is working on a fork of spidermonkey to do parallel execution
23:41:59  <pfox___>it looks like its going to be a low-level, baked in job/worker setup, of course
23:42:47  <bbenvie>still talking like
23:43:11  <pfox___>so: the future remains multicore. of course, i hope these efforts actually bear [palatable] fruit
23:43:21  <bbenvie>serialization and message passing? because if I recall spidermonkey had the ability to trade handles and that was taken out like a yerar ago
23:43:56  <bbenvie>of the api
23:44:04  <pfox___>ive done some jsapi work and never had luck with multiple contexts/compartments on a single JSRuntime* and multiple threads
23:44:06  <bnoordhuis>it also never worked right
23:44:17  <bnoordhuis>what pfox___ said
23:44:22  <pfox___>but ive had a lot of luck just doing JSRuntime* per-thread
23:44:26  <bbenvie>yeah the threading was kind of like
23:44:30  <bbenvie>could blow up randomly
23:45:00  <pfox___>i believe pjs (the parallel spidermonkey thing i mentioned) is doing the same.. but i havent really used it. just asked a few questions to the guy working on it.
23:45:01  <bbenvie>in fact it was guranteed to which is funny
23:45:11  <bbenvie>offer an api and be like
23:45:22  <bbenvie>welp this will blow up if you use it, but here it is anyway
23:45:52  <pfox___>lots of history coming to a head
23:45:57  <pfox___>but it isn't like v8 is that much better off
23:46:33  * paddybyersquit (Quit: paddybyers)
23:47:03  <bbenvie>yeah I imagine there's some psychological scarring to bnoordhuis during the isolates thing that is never going to heal
23:47:24  <pfox___>a real shame, that.
23:59:16  * pfox___quit (Ping timeout: 255 seconds)