00:46:48  <indutny_sleeping>morning
00:47:00  * indutny_sleepingchanged nick to indutny
01:08:38  * indutnychanged nick to indutny_sleeping
01:08:41  <indutny_sleeping>creationix: fixed your issues
01:08:44  <indutny_sleeping>creationix: please test
01:33:39  <creationix>morning
01:33:41  <creationix>you're up early
01:36:52  <creationix>ahh, much better
01:38:01  <creationix>testing with `nc localhost 8080 < /dev/urandom > /dev/null`
01:38:06  <creationix>it's running quite smooth
01:38:12  <creationix>test-tcp.can is a tcp echo server
01:38:31  <creationix>memory stable as 1.2Mb
01:38:40  <creationix>even less than luvit
01:44:06  * mmaleckichanged nick to mmalecki[zzz]
01:46:31  * karterkjoined
02:29:16  * alejandromgjoined
02:38:56  <creationix>now all I need to make an OOP framework is varargs of some sort
02:39:11  <creationix>... is nice syntax, not sure how to implement it though
02:40:09  <creationix>bind = (fn, self) { return function (...) { return fn(self, ...) }}
03:04:09  * karterkquit (Remote host closed the connection)
03:21:28  * karterkjoined
04:16:49  * alejandromgquit (Ping timeout: 248 seconds)
04:18:37  * alejandromgjoined
06:56:12  * alejandromgquit (Quit: leaving)
07:40:12  * karterkquit (Ping timeout: 260 seconds)
08:14:10  * karterkjoined
11:42:03  <indutny_sleeping>creationix: yt?
11:42:23  * indutny_sleepingchanged nick to indutny
11:43:13  * karterkquit (Remote host closed the connection)
12:11:21  * karterkjoined
12:33:16  <karterk>indutny: gotta run, will continue tomorrow. btw, awesome work, glad to be of some help! :)
12:33:21  <karterk>oops sorry
12:33:28  <karterk>up key on terminal :)
12:34:13  <karterk>almost done with porting the tests
12:57:25  * karterkquit (Read error: Connection reset by peer)
13:01:14  * karterkjoined
13:04:15  <karterk>indutny: I am done. All tests are currently in one big "return.can" file. Do you want them to be split up into individual .can files?
13:07:38  * karterkquit (Read error: Connection reset by peer)
13:08:36  * karterkjoined
13:16:48  * karterkquit (Read error: Connection reset by peer)
13:17:59  * karterkjoined
13:24:35  * karterkquit (Read error: Connection reset by peer)
13:28:21  * karterkjoined
13:35:47  * karterkquit (Read error: Connection reset by peer)
13:36:44  * karterkjoined
13:43:38  * karterkquit (Read error: Connection reset by peer)
13:44:05  * karterkjoined
13:54:19  * karterkquit (Read error: Connection reset by peer)
13:55:28  * karterkjoined
14:09:02  * karterkquit (Read error: Connection reset by peer)
14:09:49  * karterkjoined
14:14:52  * karterkquit (Remote host closed the connection)
14:25:33  <creationix>back
14:38:37  <creationix>indutny, you around?
15:12:34  * karterkjoined
15:17:46  * piscisaureus_joined
16:02:10  * piscisaureus_quit (Ping timeout: 246 seconds)
16:02:16  * piscisaureus__joined
16:02:22  <indutny>creationix: yes
16:02:48  <creationix>the tcp server is working well
16:02:52  <creationix>very minimal memory overhead
16:03:04  <indutny>creationix: hehe :)
16:03:07  <creationix>I think I'll switch to OOP style API though
16:03:10  <creationix>what do you think?
16:03:22  <indutny>creationix: I think it's worth trying
16:03:30  * piscisaureus__changed nick to piscisaureus_
16:03:35  <creationix>I'll just put the uv_*_t structs in the cdata
16:03:37  <indutny>experimenting with language is good anyway
16:03:40  <indutny>aaah
16:03:42  <creationix>and then there won't be any typecasting issues
16:03:48  <creationix>and store the callbacks on a candor object
16:03:49  <indutny>that's OOP
16:04:17  <creationix>so a timer object will be a fast clone of Timer with an added cdata property
16:04:29  <creationix>and all methods will look in self.cdata to find the cdata
16:04:36  <creationix>it is an extra lookup though
16:04:59  <creationix>but since there is no prototype, property lookup can be pretty fast right?
16:05:05  <indutny>creationix: that depends
16:05:17  <indutny>v8 is faster so far
16:05:21  <indutny>it's using inline caching
16:05:30  <creationix>true, but they have a serious head-start
16:05:35  <indutny>yes
16:05:57  <indutny>non-optimized candor code should be as fast as non-optimized v8
16:05:58  <creationix>also going this API, my objects are much more introspectable
16:06:00  <indutny>I hope
16:06:26  <creationix>in a rough test, I was getting 20k http reqs/s last night
16:06:31  <indutny>wooow
16:06:33  <creationix>but I was skipping http parsing and just counting bytes
16:06:37  <creationix>luvit gets 55k
16:06:41  <creationix>node about 20
16:06:42  <indutny>aah :)
16:07:03  <creationix>and luvit is parsing http
16:07:03  <indutny>well, with parsing it may reduce significally
16:07:08  <creationix>yeah, we'll see
16:07:24  <creationix>all these micro-benchmarks are pretty lame
16:07:34  <creationix>but as long as I'm doing the same thing it's somewhat comparable
16:08:12  <creationix>ok, I'm adding a module system to candor.io right now
16:08:26  <creationix>then I think I'll try oop style and benchmark my http bindings I did last night
16:08:45  <creationix>you've only just begun optimizing for speed right?
16:08:59  <indutny>creationix: yes
16:09:14  <indutny>creationix: number operations should be merely fast
16:10:09  <indutny>I mean small unboxed numbers
16:10:12  <indutny>i.e. int64_t
16:10:14  <creationix>right
16:10:26  <creationix>btw, should I use ->ToNumber() or ->As<Number>()
16:10:33  <creationix>most the time I know it's a number when I do this
16:10:42  <creationix>I've first checked with ->Is<Number>()
16:11:21  <indutny>creationix: better check Is<Number>()
16:11:32  <indutny>ah wait
16:11:51  <creationix>I noticed that As<T>() does a Is<T>() internally in an assert
16:11:58  <indutny>yes
16:12:03  <indutny>ToNumber() should be good
16:12:08  <creationix>and ToNumber() is the type coercion right?
16:12:40  <indutny>yes
16:12:48  <indutny>but it will return identity value
16:12:53  <indutny>if obj->Is<Number>()
16:13:03  <creationix>ok, so they work about the same when I'm sure it's a Number
16:13:31  <creationix>language feature wise, what did you think about ... or some sort of varargs
16:13:34  <indutny>exactly the same
16:13:50  <indutny>creationix: I don't like that
16:14:15  <indutny>it may cause a slowdown
16:14:17  <creationix>we could do arguments like in js, but then we need a way to call expand it like Function.prototype.apply does
16:14:29  <indutny>yes
16:15:13  <creationix>... is really pretty and easy to use, but I have no clue how it would be implemented
16:15:21  <creationix>[...] would convert it to an array value
16:17:14  <creationix>do you have a preference for error handling?
16:17:31  <creationix>currently, I'm exposing C-like semantics
16:17:47  <indutny>hm...
16:17:55  <karterk>indutny: what's the general idea of sticking to ECMAScript style of doing things?
16:18:10  <karterk>meaning, what will be the variance from ES
16:18:34  <creationix>uv_bind returns non-zero int on error and then you have to call uv_last_error() to get the error, I did the same for candor.io. Tcp.bind returns non-zero on error and uv.lastError() gives the error
16:19:17  <creationix>karterk, there is no prototypal inheritance, "new" does a fast shallow clone
16:19:32  <creationix>karterk, undefined and null are just nil
16:19:33  <indutny>karterk: candor is like simplified ES
16:19:49  <indutny>candor to javascript is like C to C++
16:20:06  <indutny>except candor code can't be run on ES VM
16:20:09  <karterk>ok, what about moving forward.. Meaning will that be enforced from a language roadmap point of view
16:20:41  <creationix>karterk, what do you mean "enforced"
16:20:48  <creationix>it's not a strict subset
16:20:56  <karterk>yes thats what I meant!
16:20:59  <karterk>cool
16:21:10  <creationix>and there are some features that can't be implemented easily in es
16:21:17  <creationix>objects can have any value as keys
16:21:19  <creationix>not just strings
16:21:25  <creationix>for example
16:21:40  <creationix>and since there is no "this" value, special : syntax is used for OOP style code
16:21:51  <karterk>thats changing in ES6 I believe.. WeakMaps
16:22:18  <creationix>yeah, it's not hard to implement, ES5 just doesn't have it because it would break the web
16:22:29  <creationix>people rely on 5 and "5" being the same key
16:22:30  <karterk>ok
16:22:38  <karterk>oh yeah
16:22:51  <creationix>functions don't have properties
16:22:59  <creationix>arrays only have number keys
16:23:06  <creationix>typeof doesn't lie
16:23:18  <creationix>and there is sizeof and keysof that aren't in es at all
16:23:31  <creationix>since we don't have methods on primitives like es does
16:23:39  <karterk>so far, I have not been a huge fan of languages compiling to JS - but if I ever did, I think candor would be the least I can tolerate :) I really love the simplicity so far
16:23:52  <creationix>("foo").length -> sizeof "foo"
16:24:20  <creationix>what do you mean tolerate?
16:24:33  <creationix>candor is it's own vm, it doesn't compile to js
16:24:50  <creationix>candor.js (if I ever work on it) will
16:24:56  <karterk>yes, that's what I gathered so far. I meant "IF"
16:24:59  <karterk>:)
16:25:35  <creationix>oh, and there are no exceptions
16:25:49  <karterk>node style (err, res) ?
16:25:55  <indutny>karterk: yes
16:26:08  <indutny>exceptions complicates things a lot
16:26:14  <indutny>err
16:26:17  <indutny>are complicating*
16:26:19  <karterk>cool, I usually try to avoid exceptions in Node
16:26:24  <creationix>karterk, I haven't decided what API I want for callbacks
16:26:28  <creationix>I might do node style
16:26:34  <creationix>candor.io is node in candor
16:26:44  <karterk>Scala also has the Some(), None() semantics
16:27:01  <creationix>I always liked what I called continuables
16:27:01  <karterk>tho I don't know if that will complicate things
16:27:27  <creationix>http://howtonode.org/do-it-fast
16:27:34  <creationix>function divide(a, b) { return function (callback, errback) {
16:27:50  <creationix>that will be especially useful in candor if we don't get vararg
16:28:02  <creationix>so you can still have optional arguments, but have the callback at the end
16:28:10  <karterk>nice
16:28:35  <creationix>readFile(path, optionalArg, other arg)(callback, errback)
16:29:04  <creationix>it's in between promises and node style callbacks
16:29:18  <creationix>because you can just take the return value and add the callback later
16:29:49  <karterk>and avoids nested callbacks and stuff right
16:30:02  <creationix>well, it's the same nested as node
16:30:07  <creationix>just easier to write control-flow tools
16:30:10  <karterk>ok
16:30:14  <creationix>named callbacks work just fine in node style
16:30:33  <karterk>yeah, I use async.series() etc. to manage it otherwise
16:30:35  <creationix>nesting is nice when you want closure variables
16:30:45  <karterk>true
16:30:51  <creationix>right, but those tools do nasty arguments surgery to work with node style callbacks
16:30:59  <creationix>(I know, I've written about 5 of them)
16:31:15  <karterk>I have used yours too :)
16:31:33  <indutny>brb
16:32:28  <creationix>karterk, have you looked at candor.io?
16:33:01  <karterk>no, not yet. I am looking into it now
16:34:11  <karterk>I would love to contribute in whatever way I can for both candor and candor.io though I am not a C++ or PL guy
16:36:51  <karterk>oh we need a package library too! candystore? :)
16:39:17  <karterk>creationix, what kind of module system are you looking at? Common-js style?
16:39:43  <creationix>I think I'll just use return values
16:40:01  <creationix>the only thing common-js style adds is recursive dependencies
16:40:24  <karterk>yeah, but I have never found that particularly useful ever
16:40:46  <karterk>its never a good idea anyway
16:41:16  <creationix>I'm working on modules right now
16:41:21  <creationix>refactoring everything
17:23:43  * piscisaureus_quit (Ping timeout: 246 seconds)
17:46:49  * karterkquit (Remote host closed the connection)
18:07:27  * mmalecki[zzz]changed nick to mmalecki
19:12:00  <indutny>http://www.dynamic-languages-symposium.org/dls-12/cfp/index.html
19:12:06  <indutny>do you think we may apply for that?
19:12:13  <indutny>hij1nx suggested that on twitter
19:12:58  <creationix>why not
19:13:31  <creationix>I guess the question is what's unique about candor
19:13:54  <creationix>I think the simplicity is somewhat abnormal
19:18:19  <indutny>hehe
19:19:07  <indutny>if you'll have a minute, can you prepare some sort of thesis or something?
19:19:24  <indutny>I'm very bad at writing large science texts on english
19:19:25  <indutny>:(
19:19:28  * indutnychanged nick to indutny_away
19:30:05  <creationix>yeah, don't think I'll have time for that
19:30:07  <creationix>oh well
19:30:24  <creationix>I prefer in-person conferences anyway
19:30:36  <creationix>20 minutes live presentations are a lot easier than 30 page papers
19:36:22  <indutny_away>back
19:36:28  <indutny_away>hehe
19:36:33  <indutny_away>yeah, papers are hard
19:36:38  <indutny_away>and useless, sometimes
19:36:39  <indutny_away>:)
19:36:41  * indutny_awaychanged nick to indutny
19:39:52  <mmalecki>indutny: papers are useless most of the time. actual code is useful.
19:42:20  <creationix>papers get universities money
19:42:32  <creationix>and some papers are meaningful in business
19:42:47  <creationix>but these are acm, so it's academic
19:43:02  <creationix>academics don't like practical
19:48:04  <indutny>going to sleep
19:48:05  <indutny>ttyl
19:48:08  * indutnychanged nick to indutny_sleeping
22:02:37  <creationix>wohoo, we have require for native modules in candor.io https://github.com/creationix/candor.io/commit/3cb44fd0c70acdbfe1f26e73edebf0d5473e2294
22:02:44  <creationix>and a nice colored pretty-printer too