00:00:01  * ircretaryquit (Remote host closed the connection)
00:00:10  * ircretaryjoined
00:15:20  <thl0>substack: if I need to have a require detective that also tells me what variable it was assigned what module gets me most way there?
00:15:39  <thl0>substack: i.e. 'var foo = require('./foo')' I need to know that it got assigned to foo
00:23:47  * stlsaintjoined
00:32:17  * stlsaintquit (Ping timeout: 255 seconds)
00:32:56  * thl0quit (Remote host closed the connection)
00:39:55  * stlsaintjoined
00:39:55  * stlsaintquit (Changing host)
00:39:55  * stlsaintjoined
00:49:06  * stlsaintquit (Ping timeout: 252 seconds)
01:03:20  * mikolalysenkoquit (Ping timeout: 245 seconds)
01:08:48  * fallsemojoined
01:15:21  <substack>mbalho: https://github.com/toots/buffer-browserify/pull/14 might help fix things
01:16:49  <mbalho>ooh
01:16:52  <mbalho>substack: thx will try
01:20:39  * yorickquit (Remote host closed the connection)
01:21:50  <mbalho>substack: ok so i should use that repo as the buffer-browserify dependency of insert-module-globals to test it out?
01:22:04  <substack>you could do that yes
01:24:06  <mbalho>substack: what is an easier way?
01:24:28  <mbalho>substack: ooh maybe replace it in browser-resolve
01:34:10  <mbalho>hmm didnt help
01:41:41  * thl0joined
02:00:01  <chrisdickinson>mbalho: thanks for making that github issue on js-git
02:00:22  <chrisdickinson>i'm kind of afraid that based on the single repo, he might just try to make a monolithic megapackage
02:04:14  <guybrush>it would be huge win when creationix implements it upon browserify
02:04:40  <guybrush>hopefully he jumps right on the work you already did
02:09:57  * mikolalysenkojoined
02:10:27  <substack>chrisdickinson: from observation, creationix isn't much for big packages
02:10:32  <chrisdickinson>whew
02:13:27  <thl0>substack: did a PR on https://github.com/substack/node-detective/pull/17 just now
02:13:57  <thl0>substack: that way I can figure out which var a require was assigned to
02:14:13  * mikolalysenkoquit (Ping timeout: 240 seconds)
02:22:46  * mikolalysenkojoined
02:22:47  <substack>oh cool
02:23:29  <substack>thl0: it's actually trickier if you want to see what var a require was bound to
02:23:50  <substack>especially when people or tools hoist the declarations
02:24:08  <substack>coffee-script does var a; a = require('a') when you just `a = require 'a'`
02:24:28  <thl0>substack: that's be fine I guess
02:24:44  <thl0>substack: I just need the variable name
02:25:11  <thl0>in my case to figure out what the assigned 'require("proxyquireify")' to
02:25:22  <substack>oh just make sure to check AssignmentExpression and VaribleDeclarator
02:25:45  <substack>here's how brfs does it: https://github.com/substack/brfs/blob/master/index.js#L25
02:25:50  <substack>BUT
02:25:50  <thl0>substack: the PR is ok though or do you want me to change something?
02:26:11  <substack>oh actually sweet, detective adds .parent
02:26:17  <substack>so you can just check the parent chain
02:26:22  <substack>even though it's not using falafel
02:26:26  <thl0>substack: I saw that, so I could work my way up
02:26:28  <substack>no your PR looks fine
02:26:59  <thl0>cool, I saw brfs, but didn't want to reinvent the wheel if detective already does it all ;)
02:27:32  <substack>brfs was already doing static analysis to pull out the readFileSync() calls
02:27:47  <substack>so it was easier to just add the variable checking inline
02:28:07  <substack>published 2.1.0
02:28:27  <thl0>YAY, detective will be way more useful now when it no longer withholds the real info :)
02:41:57  <mikolalysenko>here would be a cool application for falafel: doing valgrind like memory checking for full leak detection
02:42:24  <mikolalysenko>it would be awesome to know exactly where and when each object on the heap got created, and who is currently storing a reference to it
02:43:00  <mikolalysenko>you could probably fake it by replacing all of the new and array/object constructors with wrapped versions of object
02:43:13  <mikolalysenko>and by replacing all assignments with something that does reference counting
02:48:49  * xaqjoined
02:57:59  <Raynos>Domenic_: hi
02:59:39  <mbalho>i'm thinking of starting a twitter account that will only retweet dramatizations/generalizations
02:59:54  <mbalho>cause my only way to cope with drama is to subtly troll
03:00:23  <Raynos>:D
03:00:42  <mbalho>other option is to just unfollow people, thats probably better
03:01:13  <thl0>Raynos: gonna close your proxyquire issue a: because proxyquireify now does what you want b: because you don't want it anymore ^^
03:01:21  <Raynos>:D
03:03:27  * xaq_joined
03:07:05  * xaqquit (Ping timeout: 255 seconds)
03:26:19  <Raynos>Ok so I have a serious problem
03:26:28  <Raynos>My ratio of opinionated to competence is 100% out of whack
03:26:42  <Raynos>how do I deal with that :/
03:28:31  * kenperkinsjoined
03:29:19  <defunctzombie>haha
03:34:29  * Ikeymanjoined
03:36:06  <thl0>substack: with the detective change my task got rather simple: https://github.com/thlorenz/proxyquireify/blob/master/find-dependencies.js :)
03:37:23  <Raynos>defunctzombie: you owe an explanation on how coroutines solve all problems
03:37:37  * Ikeymanquit (Client Quit)
03:37:48  <defunctzombie>Raynos: do I?
03:37:56  <Raynos>you left a cliff hanger
03:38:03  <Raynos>on "this shit is trivial with coroutines"
03:38:05  <Raynos>then you went to bed
03:38:31  <defunctzombie>haha
03:38:37  <Raynos>are coroutines just co-operative scheduling?
03:39:06  <defunctzombie>https://gist.github.com/shtylman/5267456
03:39:09  <defunctzombie>did you read that rant?
03:39:53  <Raynos>maybe
03:39:55  <Raynos>let me read it again
03:40:45  <chrisdickinson>it's basically gevent
03:41:23  * defunctzombieis working on a pseudocode example
03:41:27  <chrisdickinson>with coroutines, it's not really clear to me how one would schedule many async operations to execute at once, vs. in sequence
03:41:38  <chrisdickinson>i think C# has this with async/await
03:42:02  <chrisdickinson>python's gevent has it through some really bizarre monkeypatching to make blocking code "yield" back to an event loop
03:42:18  <chrisdickinson>go, well. go's go. goroutines, and all.
03:42:28  <defunctzombie>chrisdickinson: I will show you
03:42:38  * thl0quit (Remote host closed the connection)
03:42:47  <chrisdickinson>cool
03:42:48  <chrisdickinson>thanks!
03:43:07  <Raynos>defunctzombie: as a programmer
03:43:11  <Raynos>do I need to call some kind of thing
03:43:15  <Raynos>to either create a container
03:43:19  <Raynos>or say run this function in a container
03:43:26  <defunctzombie>Raynos: no
03:43:32  <defunctzombie>not with the right library abstraction
03:43:33  <chrisdickinson>depends on the language
03:43:52  <Raynos>but how does it know that some code should run in a container and some shouldnt
03:43:58  <Raynos>or is the idea that there are sensible defaults
03:44:13  <Raynos>like the callback to `server.on('request')` goes in a seperate container by default
03:44:37  <Raynos>when within a container how do I read two files in a parallel? How do I stream two files in parallel?
03:44:51  * AvianFluquit
03:45:30  <defunctzombie>Raynos: https://gist.github.com/shtylman/5267456
03:45:40  <defunctzombie>Raynos: yes, in the trivial example you could
03:45:52  <defunctzombie>Raynos: but again, if you imagine that "requests" were already a container
03:46:06  <defunctzombie>and you pretended that all calls were sync then you wouldn't need these wrappers
03:46:25  <Raynos>ok that answers the thing
03:46:28  <defunctzombie>Raynos: the point is that the program could be written at the app level to look sync, but then use async apis
03:46:31  <Raynos>doesnt answer how I parallel ?
03:46:39  <defunctzombie>how you parallel what?
03:46:48  <Raynos>i agree 100% that you can write apps in a sync style
03:47:00  <Raynos>How do I read two files in parallel within a container?
03:47:05  <chrisdickinson>yeah, that's the thing i was asking
03:47:08  <Raynos>How do I stream two files in parallel within a container?
03:47:36  <defunctzombie>easy, use the raw callback api, let me show you
03:49:25  <defunctzombie>Raynos: refresh teh example
03:49:56  <defunctzombie>Raynos: chrisdickinson: basically, my argument is that the case of reading two files in "parallel" or whatnot can be the more "complex" api using
03:50:00  <Raynos>Ok now two streams in parallel
03:50:09  <defunctzombie>or an api that allows you to defer or whatnot
03:50:17  <defunctzombie>again, it is all about the lowest layer
03:50:21  <chrisdickinson>this is kind of why i steered away from gevent in python
03:50:22  <defunctzombie>containing the abstraction to do this
03:50:26  <Raynos>also I dont like yield & resume
03:50:33  <defunctzombie>you don't have to care about them
03:50:38  <defunctzombie>you would never use them
03:50:41  <defunctzombie>the 'fs' module would
03:50:54  <chrisdickinson>i'm not a huge fan
03:51:18  <defunctzombie>I am a very huge fan, I would use this today if I could find a way to make it bundleable to a browser setting
03:51:24  <defunctzombie>which I think I might be able to
03:51:28  <chrisdickinson>worse is better, etc etc. callbacks encompass all cases and make you think about how you're interacting with the event loop.
03:51:33  <Raynos>defunctzombie: can generators do this?
03:51:38  <defunctzombie>partially
03:51:44  <defunctzombie>you need the ability to isolate
03:51:53  <defunctzombie>generators are half the coroutine
03:52:02  <defunctzombie>if you can't isolate then you can't process other http requests
03:52:05  <Raynos>seperate question, two streams in parallel can that be done with coroutines?
03:52:07  <defunctzombie>which is what anyone cares about
03:52:22  <defunctzombie>they don't care two shits about any other "parallel" usecase
03:52:27  <defunctzombie>anything can be done
03:54:28  <defunctzombie>people who think promises or callbacks are "the way" have been using both for too long
03:54:35  <defunctzombie>imagine you are just trying to get some basic shit done
03:54:42  <defunctzombie>all of it is way too retarded and complex
03:54:55  <defunctzombie>people understand a simple step by step process
03:55:03  <defunctzombie>and what to write as little code to make that happen
03:55:20  <chrisdickinson>well, i actually like node's callback way best. and i've used the above.
03:55:30  <chrisdickinson>(mostly in python through gevent)
03:55:33  <defunctzombie>if I could use fs.readFileSync everywhere I would.. there is nothing more annoying than 10 nested read file calls because you needed to gatehr some data
03:55:50  <defunctzombie>chrisdickinson: python is annoying cause they don't have anonymous functions
03:56:00  <chrisdickinson>eeh
03:56:04  <chrisdickinson>so you have to name your functions
03:56:08  <chrisdickinson>that's not a bad thing per se
03:56:08  <defunctzombie>chrisdickinson: and things are not built on this whole model
03:56:16  <chrisdickinson>well, with gevent they are, magically
03:56:26  <defunctzombie>callbacks are nice cause they are clear, but I still want to write less code
03:57:08  <defunctzombie>gevent still has too much work
03:57:13  <defunctzombie>end users should have it simple
03:57:15  <chrisdickinson>different strokes for different folks really
03:57:20  <defunctzombie>sure
03:57:28  <chrisdickinson>i take exception to the idea that anyone can say what everyone should be using
03:57:29  <defunctzombie>my arguments stem from what I think is simple
03:57:36  <defunctzombie>irregardless of what is currently "possible"
03:57:47  <defunctzombie>if I was to learn how to program today
03:57:55  <defunctzombie>I don't give two shits about promises or callbacks
03:58:00  <defunctzombie>or the "philosophy" of either
03:58:10  <defunctzombie>I need to read a file and do some shit
03:58:18  <defunctzombie>and I want 1 api to do that
03:58:31  <defunctzombie>I don't wnat to learn 30 async vs sync apis etc
03:58:38  <defunctzombie>and I think we CAN accomplish that eventually
03:58:48  <defunctzombie>but no one is thinking about it like that, oh wells :)
03:59:27  <defunctzombie>until then, people can use whatever the fuck they want to get their shit done
03:59:50  <defunctzombie>I will use a library built on promises or callbacks as long as it works and I can debug it
04:00:29  * kenperkinsquit (Quit: Computer has gone to sleep.)
04:01:36  <Raynos>defunctzombie: I think I would like it if node returned a partial function application for callbacks
04:01:40  <Raynos>that would solve most problems
04:02:33  <Raynos>defunctzombie: I see your point though. The problem is I dont know enough about coroutines to be able to tell whether they are a bad idea
04:04:17  <substack>just write an ast transform to implement await
04:04:29  <substack>then we can experiment with it to decide whether it's a worthwhile approach
04:06:04  <substack>Domenic_: maybe you can enlighten me or this is just a bad example https://gist.github.com/wycats/5279394#comment-808215
04:08:25  <substack>I can think of async code that turned out pretty complicated that would perhaps make a better example
04:09:01  <substack>but if an abstraction only shows its use at the later stages that is much harder to communicate
04:09:42  * fallsemoquit (Quit: Leaving.)
04:10:02  * mikolalysenkoquit (Ping timeout: 256 seconds)
04:13:02  <defunctzombie>substack: an ast transform might be possible
04:13:16  * defunctzombiethinks about it
04:13:30  <defunctzombie>https://gist.github.com/wycats/5279394#comment-808215
04:13:35  <defunctzombie>all of the code here is bullshit
04:13:56  <defunctzombie>what you really want is fs.mkdir; fs.open; fs.write
04:14:04  <defunctzombie>user DOES NOT CARE ABOUT YOUR IO MODEL
04:15:02  <Raynos>substack: I think that's not a bad example
04:15:36  * xaq_quit (Remote host closed the connection)
04:17:49  * mikolalysenkojoined
04:28:59  <defunctzombie>substack: the ast transform is an interesting idea
04:29:31  <defunctzombie>thinking about what would be needed to detect the stuff properly
04:29:53  <defunctzombie>methinks you can get away with just introducing a global __defer() or such that your shims would return
04:30:00  <defunctzombie>this would then be easy to spot in the ast
04:30:09  <defunctzombie>and allow the runtime to work properly above it
04:31:18  * mikolalysenkoquit (Ping timeout: 252 seconds)
04:32:43  <defunctzombie>maybe something like the following: https://gist.github.com/shtylman/5279559
04:33:14  * ousiajoined
04:33:15  <defunctzombie>basically, you would provide a new 'fs' or 'net' lib that would be educated about some things and require the use of the ast transform to work obviously
04:35:05  <defunctzombie>the main advantage to ast approach over the 'node fibers' approach
04:35:11  <defunctzombie>is that you can have the code work client side too
04:35:26  * Raynos_joined
04:35:31  <Raynos_>substack: https://gist.github.com/Raynos/5279565
04:36:00  <Raynos_>Exact same as callbacks except easier to write fancy pants chainable things
04:36:18  <Raynos_>There's definitely something to be said about returning values
04:36:21  <defunctzombie>are you joking?
04:36:36  <defunctzombie>really? that is the answer to how to make a dir, open an fd and write some data
04:36:44  <defunctzombie>come on.. I mean.. look at it
04:37:01  <defunctzombie>this is the same mental delusion lisp people suffer
04:37:17  <defunctzombie>they don't see the shit they are writing and think normal people want to write that
04:39:12  * Raynosquit (Remote host closed the connection)
04:39:12  * sveisveiquit (Remote host closed the connection)
04:39:12  * owenbquit (Remote host closed the connection)
04:39:12  * duncanbeevers_quit (Remote host closed the connection)
04:39:12  * ehdquit (Remote host closed the connection)
04:39:13  * pikpikquit (Remote host closed the connection)
04:39:13  <Raynos_>Actually https://gist.github.com/Raynos/5279565#file-callbacks-js-L177
04:39:13  * notalexgordon_quit (Remote host closed the connection)
04:39:13  * ryanseddonquit (Remote host closed the connection)
04:39:14  * niftylettucequit (Write error: Connection reset by peer)
04:39:16  <Raynos_>Actually https://gist.github.com/Raynos/5279565#file-callbacks-js-L177
04:42:11  <Raynos_>defunctzombie: It's messy, https://gist.github.com/Raynos/5279565#file-callbacks-js-L193
04:42:43  <Raynos_>I think you could rename `map` to lift and claim these things are monads :D
04:43:45  <Raynos_>defunctzombie: note that all intermediate formats are lazy representation of IO
04:43:50  <Raynos_>FUCK I WROTE AN IO MONAD ;_:
04:43:51  <LOUDBOT>IF I CAN GET HIM TO COME OUT OF THE FUCKING CLOSET
04:44:26  <substack>Raynos_: I don't like chainable things
04:44:53  <Raynos_>substack: I thought you liked streams because of chaining
04:45:04  <Raynos_>It works without chaining sugar ( https://gist.github.com/Raynos/5279565#file-callbacks-js-L193 )
04:45:40  <substack>I like some shallow chaining
04:45:52  <substack>when it gets complicated, like when there are callbacks, I like it much better not chained
04:47:04  <Raynos_>just imagine that `map(cb)` is like `through(function (data) { })`
04:47:19  <substack>so actually what we need
04:47:20  <substack>is bash
04:47:23  <Raynos_>bash?
04:49:42  <substack>https://gist.github.com/wycats/5279394#comment-808225
04:50:28  * nk109joined
04:50:52  * nk109quit (Client Quit)
04:50:53  <substack>we need a bash -> js transpiler so that bash can use js data structures in-memory
04:55:16  <defunctzombie>haha
04:55:29  <Raynos_>substack: that sounds like a good idea
04:55:36  <Raynos_>it would make it super easy for me to learn unix / bash !
04:55:39  <substack>I would *much* rather just use inline bash than promises or wonky flow control libs
04:56:19  <jesusabdullah>the obvious thing missing here is that the thing promises give you that straight callbacks don't is an object that you can pass around
04:56:36  <jesusabdullah>like, var promise = someFunctionThatReturnsAPromise(args);
04:56:55  <jesusabdullah>and then you can pass that around to something that does promise.then(function (err, data) {});
04:57:03  <jesusabdullah>why you're doing this idk
04:57:04  <Raynos_>jesusabdullah: https://gist.github.com/Raynos/5279565#file-callbacks-js-L13
04:57:21  <Raynos_>partial function application allows you to do that
04:57:24  <jesusabdullah>I mean, basically yeah
04:57:31  <jesusabdullah>that's the essence of a promise there
04:57:39  <Raynos_>No
04:57:46  <Raynos_>that's the essence of an IO monad there >_<
04:58:04  <jesusabdullah>though, presumably, a promise could also hold onto a result indefinitely in case you hold onto the thing for a while
04:58:12  <jesusabdullah>yeah well I refuse to speak haskell
04:58:16  <jesusabdullah>much less monads
04:59:01  <substack>Raynos_: monads are noun-thinking
04:59:16  <jesusabdullah>"monad" is a word I don't need right now
04:59:19  <Raynos_>Agreed
04:59:40  <Raynos_>I actually think holding onto a result indefinitely is harmful
04:59:58  <Raynos_>that's just unnecessary buffering of all your streams and buffers and bloating your memory usage
05:02:10  <jesusabdullah>I mean
05:02:21  <jesusabdullah>I don't think we can make that conclusion
05:02:23  <jesusabdullah>as of yet
05:02:37  <jesusabdullah>surely there is a reason that you would want to do this
05:04:19  <Raynos_>sure
05:04:23  <Raynos_>but it shouldnt be the default
05:04:25  <Raynos_>it should be opt in
05:04:33  <Raynos_>and it's trivial to write a function that does it
05:05:56  <jesusabdullah>or, y'know, to require it from userspace
05:05:57  <Raynos_>jesusabdullah: https://gist.github.com/Raynos/84ea6e7fea8f25dd5abe tada
05:06:08  <jesusabdullah>presumably there is more than one implementation
05:06:31  <Raynos_>It's 15 lines. it's trivial.
05:06:52  <jesusabdullah>isn't there a race condition in there?
05:06:53  <jesusabdullah>I mean
05:06:56  <jesusabdullah>I agree it's not hard
05:07:08  <jesusabdullah>but it looks to ME like that callback would get called twice
05:07:45  <Raynos_>there's a return statement
05:07:54  <Raynos_>oh yeah
05:07:55  <Raynos_>your right
05:07:58  <Raynos_>there is a race condition :P
05:08:29  <jesusabdullah>I mean
05:08:39  <jesusabdullah>point is, promise-like constructs aren't hard to implement
05:08:46  <jesusabdullah>the question is, when are they actually useful
05:08:54  <jesusabdullah>and presumably they are for certain cases
05:08:54  <Raynos_>Fixed it ( https://gist.github.com/Raynos/84ea6e7fea8f25dd5abe )
05:09:13  * defunctzombiechanged nick to defunctzombie_zz
05:09:23  <Raynos_>they are useful for poisoning your codebase :P
05:10:16  <Raynos_>btw my callbacks example is just a simplified version of dominictarr/pull-stream. You can write streams in the exact same fashion
05:10:26  <jesusabdullah>sure
05:10:27  <jesusabdullah>though
05:10:34  <jesusabdullah>I'm of the belief that streams are overused
05:11:08  <Raynos_>not really
05:11:08  <jesusabdullah>an unpopular opinion I'm sure
05:11:11  <jesusabdullah>but one I hold nonetheless
05:11:20  <Raynos_>it's a trade-off between backpressure & easy of API
05:11:34  <Raynos_>streams at complexity but also enable back pressure
05:11:38  <jesusabdullah>and square-peg-round-hole
05:11:52  <Raynos_>I agree 100% that streams are a really complex beast
05:11:58  <jesusabdullah>it's not even complexity
05:12:07  <jesusabdullah>it's that they're often straight up the wrong abstraction
05:12:18  <Raynos_>when are they used for non streaming data?
05:12:40  <Raynos_>can you give an example of "the wrong abstraction"
05:12:54  <jesusabdullah>If your "stream" is passing around objects
05:12:58  <jesusabdullah>it's not a stream
05:13:44  <Raynos_>yes
05:13:45  <Raynos_>BUT
05:13:48  <jesusabdullah>I'll admit I'm not ready to debate this claim, I'm unprepared and have a migraine
05:14:07  <Raynos_>if one of the intermediate through streams has objects and both the input & output streams have bytes then its a convenient way to handle backpressure
05:14:26  <jesusabdullah>perhaps
05:14:30  <jesusabdullah>I'm still skeptical
05:14:37  <Raynos_>if either your input or output stream is of objects then your doing it wrong :D
05:14:52  <jesusabdullah>I'd say that's sufficient common ground
05:15:10  <Raynos_>if you use an event emitter in between two streams of bytes then just make sure you dont break backpressure
05:15:23  <Raynos_>I broke backpressure with my fancy pants event emitters and now we leak memory :(
05:15:43  <jesusabdullah>we should call "object streams" stroms
05:15:58  <jesusabdullah>because a) derp and b) o is for object
05:16:02  <jesusabdullah>but mostly c) derp
05:16:09  <jesusabdullah>strom.pope
05:16:34  <Raynos_>strom.poop
05:18:19  <substack>the answer is very obvious
05:18:22  <substack>implement bash in js
05:18:50  <substack>you get an imperitive structure that programmers already know that places nicely with streams
05:18:55  <substack>done
05:19:16  <Raynos_>substack: how do I implement bash in js?
05:19:19  <jesusabdullah>I think that's harder than you expect
05:19:24  <substack>Raynos_: one sec
05:19:27  <jesusabdullah>and also less valuable
05:19:28  <substack>already started
05:19:30  <substack>nah it's easy
05:19:38  <substack>all the hard parts are already finished
05:20:38  <Raynos_>substack: https://github.com/akidee/js2bash
05:21:11  <substack>wrong direction
05:21:20  <Raynos_>substack: https://github.com/arturadib/shelljs ?
05:22:26  <substack>WOW
05:22:52  <substack>oh wait this is non-node
05:22:57  <substack>uses sync io
05:23:50  <substack>oh no, for node.js it says hmm
05:26:13  <Raynos_>its for node.js & 100% sync io
05:27:40  <substack>well if that lib just pushed onto a scheduler instead of doing sync io that would work
05:28:09  <Raynos_>how would you implement a scheduler?
05:28:30  <Raynos_>how would their ls thing work? ( https://github.com/arturadib/shelljs#javascript )
05:30:18  <substack>it's easy if you have .forEach()
05:37:23  * mikolalysenkojoined
05:39:36  <Raynos_>substack: how do you do forEach without blocking IO. I guess forEach can be async
05:41:46  * jcrugzzquit (Quit: leaving)
05:42:34  * mikolalysenkoquit (Ping timeout: 272 seconds)
05:45:41  <substack>yes
05:45:51  <substack>function forEach (cb) {}
05:46:41  * nk109joined
05:54:38  * nk109quit (Quit: Computer has gone to sleep.)
06:03:23  <jesusabdullah>require('async').forEachSeries
06:03:27  <jesusabdullah>or something like this
06:03:44  <jesusabdullah>if async has too many helpers for you copypaste or find something of similar spirit
06:14:02  <Raynos_>what happens in node when I make two concurrent writes to the same file descriptor
06:27:40  * mikealjoined
06:29:11  * mikealquit (Client Quit)
06:31:15  <substack>Raynos_: https://github.com/substack/bashful
06:33:55  <Raynos_>so i literally have to implement all of bash in non blocking streaming JS ?
06:34:05  <Raynos_>that sounds like a bitch
06:36:19  <substack>just trick the internet to do it for you
06:36:20  <substack>watch
06:38:20  <Raynos_>:D
06:43:34  <substack>https://twitter.com/substack/status/318251963923976192
06:46:03  <substack>dominictarr just hit 200 npm modules I see
06:46:10  <substack>that makes 4 people with >=200
07:02:51  <chrisdickinson>i finally topped 100 :D
07:03:41  <jesusabdullah>I have no idea how many I have but I know it's not that many
07:04:00  <jesusabdullah>because I tend to collaborate on code more than I spin off my own stuff
07:04:14  <jesusabdullah>and I'm okay with that!
07:05:27  <Domenic_>substack: Raynos_: would love to talk about promises with you guys sometime but not until my HTML5DevConf talk is over :)
07:06:06  <Raynos_>Domenic_: did you see https://gist.github.com/Raynos/5279565 ?
07:06:15  <Raynos_>we should hang out on monday / whenever
07:06:33  <Raynos_>Domenic_: btw I havn't mentally prepared anything for html5conf, is it going to be messy?
07:08:06  <substack>how long are the sessions even supposed to be?
07:08:29  <substack>my last one was 50 minutes but I have no idea how long I'm supposed to talk for this time
07:10:47  <substack>ok yep, 50 minutes this time too 2:30pm - 3:20pm
07:11:24  <substack>oh crap, april 1st
07:11:30  <substack>I thought I was speaking april 2nd
07:12:25  <substack>anyways I have plenty of examples so that part shouldn't be a problem
07:20:23  * Domenic_quit (Ping timeout: 246 seconds)
07:23:30  <Raynos_>Another thing -> https://gist.github.com/Raynos/7b1ffc4cce99a68715e5
07:24:09  <Raynos_>substack: Talk about the awesome of being able to use your package manager when github is down
08:42:54  * ousiaquit (Ping timeout: 276 seconds)
08:45:43  * ousiajoined
09:01:17  <Raynos_>something went horribly wrong
09:01:21  <Raynos_>I spend the last half hour
09:01:24  <Raynos_>recursing in my head
09:01:37  <Raynos_>my brain got stuck into an infinite loop
09:07:13  <pkrumins>did you try turning it off and on again?
09:22:20  <dools_>people try that sometimes. it doesn't end well
09:40:24  <Raynos_>o_o;
09:40:36  <Raynos_>I just spend another 40 minutes
09:40:41  <Raynos_>trying to `break;` the recursions
09:40:46  <Raynos_>and I'm like FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFf
09:40:53  <Raynos_>LISP Y U NO ACCEPT `break;` keyword
09:44:03  * thl0joined
09:58:10  * ins0mniajoined
10:05:59  * ousiaquit (Remote host closed the connection)
10:07:59  * ousiajoined
10:13:16  * ehdjoined
10:13:41  * ins0mniaquit (Ping timeout: 255 seconds)
10:13:49  * notalexgordon_joined
10:14:27  * duncanbeevers_joined
10:15:14  * ryanseddonjoined
10:15:38  * dominictarrjoined
10:19:20  * duncanbeevers_quit (Remote host closed the connection)
10:19:20  * notalexgordon_quit (Remote host closed the connection)
10:19:53  * ryanseddonquit (Remote host closed the connection)
10:19:53  * ehdquit (Remote host closed the connection)
10:34:55  * dfgg_changed nick to dfgg
10:43:30  * dominictarrquit (Quit: dominictarr)
10:55:55  * dominictarrjoined
11:03:10  * dominictarrquit (Quit: dominictarr)
11:16:05  * ehdjoined
11:26:14  * ehdquit (Remote host closed the connection)
11:42:12  * dominictarrjoined
11:45:52  * ousiaquit (Read error: Connection reset by peer)
11:49:07  * yorickjoined
12:10:44  * ins0mniajoined
12:17:30  * ehdjoined
12:19:06  * notalexgordon_joined
12:21:14  * duncanbeevers_joined
12:21:15  * duncanbeevers__joined
12:21:34  * duncanbeevers_quit (Client Quit)
12:21:35  * duncanbeevers__quit (Client Quit)
12:23:48  * ryanseddonjoined
12:40:03  * owenbjoined
12:42:52  * niftylettucejoined
12:45:47  * dominictarrquit (Ping timeout: 255 seconds)
12:57:57  * Raynosjoined
12:58:25  * sveisveijoined
13:09:58  * thl0quit (Remote host closed the connection)
13:10:04  * pikpikjoined
13:10:16  * nicholas_joined
13:38:39  * jibayjoined
13:39:37  * mikolalysenkojoined
13:44:52  * fallsemojoined
13:46:42  * fallsemoquit (Client Quit)
13:55:05  * ins0mniaquit (Ping timeout: 255 seconds)
13:56:45  * thl0joined
13:57:47  <juliangruber>woah, peerconf was awesome
13:58:06  <juliangruber>learning from david gothberg directly
13:58:12  <juliangruber>and hanging out and stuff
14:16:14  * mikolalysenkoquit (Ping timeout: 245 seconds)
14:19:52  * mikolalysenkojoined
14:21:56  * ins0mniajoined
14:52:24  * kenperkinsjoined
15:05:35  * kenperkinsquit (Quit: Computer has gone to sleep.)
15:09:24  * dominictarrjoined
15:16:38  * dominictarrquit (Ping timeout: 256 seconds)
15:18:26  * dominictarrjoined
15:21:47  * thl0quit (Remote host closed the connection)
15:27:49  * dominictarrquit (Quit: dominictarr)
15:31:58  * defunctzombie_zzchanged nick to defunctzombie
15:35:09  * ins0mniaquit (Ping timeout: 252 seconds)
15:37:28  * thl0joined
15:38:03  * jcrugzzjoined
15:48:28  * jcrugzzquit (Quit: leaving)
15:58:26  <Ralt>Raynos_: lisp?
16:02:58  * xaqjoined
16:09:26  <mbalho>juliangruber: did anyone take notes
16:18:25  * mikolalysenkoquit (Ping timeout: 256 seconds)
16:21:11  * mikolalysenkojoined
16:24:27  * thl0quit (Remote host closed the connection)
17:11:24  <rvagg>mbalho: no, we lounged around, asking questions, discussing and generally trying to absorb. was all videoed
17:12:18  * Altreusquit (Changing host)
17:12:19  * Altreusjoined
17:19:06  * kenperkinsjoined
17:20:10  * Correnjoined
17:23:35  * kenperkinsquit (Ping timeout: 258 seconds)
17:23:36  * Correnchanged nick to kenperkins
17:25:41  * calvinfoquit (Ping timeout: 255 seconds)
17:25:49  * timoxleyjoined
17:36:13  * thl0joined
17:37:48  * mikolalysenkoquit (Ping timeout: 252 seconds)
17:47:52  * ins0mniajoined
17:50:12  * mikolalysenkojoined
18:06:04  * mikolalysenkoquit (Ping timeout: 256 seconds)
18:11:11  * calvinfojoined
18:18:04  <juliangruber>mbalho: videos will be published
18:18:47  <juliangruber>also, eoinbrazil tweeted many references to papers https://twitter.com/search/realtime?q=%23peerconf&src=hash
18:22:01  * fallsemojoined
18:32:02  * mikolalysenkojoined
18:40:40  * kenperkinsquit (Quit: Computer has gone to sleep.)
18:41:49  * xaqquit (Remote host closed the connection)
18:42:37  * xaqjoined
18:46:56  * xaqquit (Ping timeout: 256 seconds)
18:54:41  * fallsemoquit (Quit: Leaving.)
18:56:47  * fallsemojoined
19:00:31  * fallsemoquit (Client Quit)
19:04:39  * kenperkinsjoined
19:14:10  * AvianFlujoined
19:14:13  <juliangruber>mbalho: the basic takeaway was to use hashtables and public key cryptography for everything, also that distributed things can by super simple
19:31:51  <thl0>hey, does anyone know ForbesLindsay's github?
19:32:15  <thl0>want to mention him in my post since he helped with source maps
19:33:21  * xaqjoined
19:33:45  <thl0>substack: you must know him right - Forbes Lindsay or something similar
19:35:19  <pkrumins>github.com/forbeslindesay
19:37:35  <thl0>pkrumins: thanks
19:46:56  * mikolalysenkoquit (Ping timeout: 256 seconds)
20:08:19  * fallsemojoined
20:26:38  * defunctzombiechanged nick to defunctzombie_zz
20:31:27  <chrisdickinson>ahaha, it works
20:33:30  * ryanseddonquit (Write error: Broken pipe)
20:33:30  * owenbquit (Write error: Broken pipe)
20:35:29  * defunctzombie_zzchanged nick to defunctzombie
20:37:49  * owenbjoined
20:37:53  * ryanseddonjoined
20:53:09  <chapel>hows it going chrisdickinson ?
20:55:52  <owen1>juliangruber: how was Fred George's talk? was the same as the anarchy talk (http://vimeo.com/32447325)?
20:57:53  <juliangruber>owen1: very similar to that one, yes. I really enjoyed it!
20:58:07  <juliangruber>but I'm still not sure how I can make my employer try this out
20:58:21  <juliangruber>except: hey, trust me, I guide this, let's try it for a project
20:58:28  <juliangruber>do you have experience with that?
20:59:43  <owen1>juliangruber: no but i want to! (:
21:00:00  * defunctzombiechanged nick to defunctzombie_zz
21:00:02  <owen1>it sounds awesome. he mentioned constant re-write.
21:00:07  <owen1>from ruby to node
21:00:18  <owen1>or something to clojure and clojure again
21:00:21  <juliangruber>yeah, rewrites are awesome
21:00:24  <owen1>and almost no tests!
21:00:38  <juliangruber>I don't really agree with that one
21:00:49  <juliangruber>100 sloc is far too much for not having tests
21:02:12  <owen1>did he used the exact slides as those? http://www.slideshare.net/fredgeorge/programmer-anarchy-chinese
21:02:25  <owen1>his experience at 'forward'
21:03:34  <juliangruber>nope
21:04:06  * fallsemoquit (Quit: Leaving.)
21:04:08  <owen1>good. if u like the guy he had another talk about micro-soa - http://youtu.be/2rKEveL55TY (havn't watched it)
21:04:32  <juliangruber>oh, awesome
21:04:35  <juliangruber>will do, thanks
21:05:37  <owen1>btw, thanks to Rod and Paolo (nodeup 41) i started experimenting with leveldb. any insight about that in peepconf?
21:06:52  * st_lukejoined
21:08:05  <owen1>i use levelup but not sure if it's a decent replacement for mongo/redis. i can save json object in keys. will i be able to use it for a blog app or rss reader app? i don't know yet but i'll find it out soon!
21:09:19  * xaqquit (Remote host closed the connection)
21:11:39  * xaqjoined
21:12:19  * jez0990quit (Quit: http://quassel-irc.org - Chat comfortably. Anywhere.)
21:13:13  * xaqquit (Remote host closed the connection)
21:13:41  * jez0990joined
21:15:20  <juliangruber>owen1: definitely!
21:16:07  <juliangruber>just give it a shot and you'll see how much simpler your app becomes
21:16:13  <owen1>juliangruber: definitely for 'leveldb can be used for a blog app and an rss readerapp'?
21:16:21  <juliangruber>yes
21:16:43  <juliangruber>let's continue in ##leveldb?
21:16:45  <owen1>how do i store my authors/blogs info/blog body?
21:17:07  <owen1>already there!
21:22:21  * stlsaintjoined
21:38:25  * ryanseddonquit (Remote host closed the connection)
21:39:01  * owenbquit (Remote host closed the connection)
21:39:06  * ehdquit (Remote host closed the connection)
21:39:06  * notalexgordon_quit (Remote host closed the connection)
21:39:06  * Raynosquit (Remote host closed the connection)
21:39:06  * pikpikquit (Remote host closed the connection)
21:39:07  * sveisveiquit (Write error: Broken pipe)
21:39:07  * niftylettucequit (Write error: Broken pipe)
21:39:33  * xaqjoined
21:56:40  * defunctzombie_zzchanged nick to defunctzombie
22:04:37  * dguttmanjoined
22:18:28  * dguttman_joined
22:18:50  * dguttmanquit (Ping timeout: 246 seconds)
22:18:50  * dguttman_changed nick to dguttman
22:23:28  * dguttmanquit (Quit: dguttman)
22:32:35  * dguttmanjoined
22:35:27  * tmcwjoined
22:36:22  * tilgovijoined
22:37:05  * tmcwquit (Remote host closed the connection)
22:37:13  * tmcwjoined
22:38:11  * xaqquit (Remote host closed the connection)
22:39:05  * ehdjoined
22:42:14  * notalexgordon_joined
22:43:40  * Spion_joined
22:43:49  * tmcwquit (Read error: Connection reset by peer)
22:51:39  * ryanseddonjoined
22:59:31  * st_lukequit (Remote host closed the connection)
23:03:28  * thl0quit (Remote host closed the connection)
23:12:46  * jibayquit (Remote host closed the connection)
23:15:52  * defunctzombiechanged nick to defunctzombie_zz
23:21:14  * timoxleyquit (Quit: Computer has gone to sleep.)
23:22:27  * st_lukejoined
23:24:07  * owenbjoined
23:25:34  * niftylettucejoined
23:31:22  * dguttmanquit (Quit: dguttman)
23:37:03  * thl0joined
23:38:57  * thl0quit (Remote host closed the connection)
23:41:29  * thl0joined
23:44:48  * thl0quit (Remote host closed the connection)
23:50:04  * Raynosjoined
23:51:11  * sveisveijoined
23:54:09  * fallsemojoined
23:54:43  * mikealjoined
23:56:04  <fotoverite>So is google treasure going to be an ongoing arg after april 1st? Would actually be fun.
23:57:59  * thl0joined