00:00:02  * ircretaryquit (Remote host closed the connection)
00:00:11  * ircretaryjoined
00:02:10  * wiwilliaquit (Ping timeout: 260 seconds)
00:05:37  <Raynos>mbalho: and back pressure!
00:05:53  <Raynos>mbalho: I use mdm a lot, what is it?
00:06:01  <CoverSlide>ecstasy?
00:07:06  <Raynos>isaacs: when you pipe a stream into a transform you pipe one "stream over time" into another "stream over time" the transform stream simply returns a stream. It doesn't have this notion that each chunk in the original stream was transformed into the other stream in the same order
00:07:26  <isaacs>i guess
00:07:35  <isaacs>but doing it in parallel is certainly unusual and weird.
00:07:36  <Raynos>isaacs: I guess a transformation stream that respects order is nicer because its inversable
00:07:54  <Raynos>isaacs: if the transformation operation is commutative then why not parallelize it
00:08:05  <isaacs>i gues
00:08:13  <isaacs>but i don't see the value in adding that kind of machinery to node core.
00:08:15  <isaacs>since we never ever do that.
00:08:26  <isaacs>zlib and crypto can't work that way
00:09:12  * tilgoviquit (Ping timeout: 264 seconds)
00:09:23  <Raynos>isaacs: is there no commutative transformation stream in node-core ?
00:09:49  <Raynos>I guess the only transforms are zlib and crypto
00:11:15  <Raynos>isaacs: the only value in adding it to node-core is completeness and having a single correct implementation instead of 20 buggy ones
00:11:54  <Raynos>but that's bullshit, userland should self organize and not be buggy
00:12:25  <CoverSlide>isaacs: still trying to understand streams2, so basically I have a streaming parser thing, which has a read() method, and collects an array of buffers and has a cursor to know where to start reading from, returns false if it requests more bytes than there are available. essentially does the new stream interface make this obsolete?
00:15:14  <isaacs>CoverSlide: talk to Raynos, I'm in the middle of tracking down a bug atm.
00:15:19  <CoverSlide>oh ok
00:15:23  <Raynos>CoverSlide: probably. streams2 is a pull stream where you can pull values out
00:15:29  <isaacs>CoverSlide: i can answer surface questions, but i'm already in a stack, can't dive into another one :)
00:16:11  <Raynos>CoverSlide: Actually I think streams2 will return 10 bytes if you read(20) im not sure
00:17:34  <CoverSlide>hmm
00:18:56  <Raynos>CoverSlide: nope wrong. read(20) returns null if there are 10 bytes
00:19:05  <Raynos>so yes streams2 makes your thing redundant
00:30:13  * ins0mniaquit (Ping timeout: 246 seconds)
00:31:36  * ralphtheninjajoined
00:35:17  * dominictarrquit (Quit: dominictarr)
00:38:05  * jibayquit (Quit: Leaving)
00:42:28  <mbalho>Raynos: there are just incorrect examples in the mdm readme is all
00:43:04  <Raynos>mbalho: there are?
00:43:20  <mbalho>Raynos: yea after i get my thing working i can fix em
00:43:26  <Raynos>heh
00:45:03  * tilgovijoined
00:47:20  * wiwilliajoined
00:51:13  <substack>mbalho: https://0fps.wordpress.com/2013/01/15/new-years-resolution-post-more-stuff-on-npm/
00:53:10  <chrisdickinson>woo!
01:00:17  <mbalho>substack: WOO!!!
01:00:20  <mbalho>substack: that blog post rules
01:00:32  <Raynos>chrisdickinson: https://github.com/mikolalysenko/Serverify/issues/1
01:01:17  <chrisdickinson>Raynos: ah, guessing you're referring to browservefy there too :)
01:01:22  <Raynos>yes!
01:01:26  <Raynos>not directly
01:01:31  <Raynos>but all of those tools are annoying
01:01:48  <chrisdickinson>annoying how?
01:01:49  <mbalho>substack: come test the new voxel server! you can also refresh and it will sync the world changes to you over scuttlebutt
01:01:55  <mbalho>http://voxel.jit.su
01:02:55  <Raynos>chrisdickinson: too much bullshit gets scaffolded
01:03:01  <Raynos>too many commands to run
01:03:10  <chrisdickinson>ah, mine doesn't really scaffold, which is the only problem i've had with mine
01:03:31  <chrisdickinson>it just serves up the directory and browserifies a single path
01:03:38  <Raynos>chrisdickinson: well however I try either the "server tool does everything" is inflexible or the scaffolding generates too much bullshit
01:04:04  <chrisdickinson>i'd say having a default index.html if one doesn't exist would fix the problem
01:04:11  <chrisdickinson>then you can add an index.html later
01:04:15  <chrisdickinson>(if you need to)
01:04:43  <Raynos>chrisdickinson: probably
01:05:09  <mbalho>substack: whoa its buggy hahahaha
01:05:11  <chrisdickinson>i generally don't like scaffolding much
01:05:29  <Raynos>chrisdickinson: The only scaffolding I like is auto generated package.json and Makefil
01:05:38  * chrisdickinsonnods
01:05:48  <Raynos>and also project -.-
01:06:07  <Raynos>https://github.com/Raynos/ngen/tree/raynos/templates/testling/content so much bullshit
01:06:08  <Raynos>it is sad
01:06:22  <chrisdickinson>oh nice
01:06:37  <chrisdickinson>is that published on npm?
01:06:54  <Raynos>yes
01:06:56  <Raynos>raynos-ngen
01:06:58  <chrisdickinson>sweet
01:07:10  <Raynos>it may have my name hardcoded in the template somewhere :D
01:08:22  <chrisdickinson>i'd say that scaffolding and "lightweight browserify server" should be separate
01:08:37  <chrisdickinson>and we could just have a default empty index.html for things missing dirs
01:08:44  <mbalho>Raynos: is there a LRU or anything built into scuttlebutt/model
01:08:53  <Raynos>mbalho: use Raynos/expiry-model
01:09:03  <Raynos>scuttlebutt/model has no LRU
01:09:20  <shama>ahh Im being buried alive
01:09:23  <Raynos>expiry-model is build to not expand in memory usage
01:10:19  <mbalho>shama: there are tons of bugs still but its getting there
01:10:41  <shama>its totally awesome
01:12:30  <mbalho>AHAHAHahaha
01:12:32  <shama>lol
01:13:03  <mbalho>ok gotta run
01:19:53  * ryan_stevensjoined
01:20:10  * ryan_stevensquit (Client Quit)
01:22:28  * ryan_stevensjoined
01:24:01  * ryan_stevensquit (Remote host closed the connection)
02:11:19  * shamaquit (Quit: shama)
02:17:43  * nk109quit (Quit: Computer has gone to sleep.)
03:01:24  * shamajoined
03:02:08  * shamaquit (Client Quit)
03:16:36  * wiwilliaquit (Ping timeout: 248 seconds)
04:02:45  * devaholicquit (Ping timeout: 276 seconds)
04:11:13  * shamajoined
04:12:27  * shamaquit (Client Quit)
04:32:08  * exit2joined
04:48:59  * fotoveritejoined
04:52:05  * dominictarrjoined
04:52:08  * fotoveritequit (Read error: Connection reset by peer)
04:52:12  * fotoverite_joined
04:52:13  * exit2quit (Remote host closed the connection)
04:55:12  * fotoveritejoined
04:56:54  * fotoverite_quit (Ping timeout: 252 seconds)
04:59:15  * dominictarrquit (Ping timeout: 248 seconds)
05:03:08  * mikolajoined
05:03:14  <mikola>hi
05:18:48  <substack>ahoy
05:19:19  <mikola>hey, nice job with voxeljs
05:20:10  * substackpartially fixed the collision detection just now
05:20:15  <substack>it's better at least
05:21:54  * wiwilliajoined
05:22:00  <substack>now finishing the pricing widget!
05:22:11  <Raynos>mikola: o/
05:22:25  <Raynos>thanks for feedback on browserify-server
05:23:07  <mikola>Raynos: hey, no problem
05:23:12  <substack>Raynos: eh?
05:23:18  <mikola>I also changed the readme on serverify
05:23:22  <Raynos>also awesome work on modules!
05:23:29  <mikola>thanks!
05:23:48  <mikola>I am putting together a little thing to deal with massive narrow band level sets in javascript
05:23:50  <Raynos>substack: https://github.com/mikolalysenko/Serverify https://github.com/Raynos/browserify-server
05:25:41  * coffeecup_joined
05:36:40  <defunctzombie>should get serverify to support npm-css haha
05:51:31  * dominictarrjoined
05:54:59  <Raynos>dominictarr: https://gist.github.com/477c8b821ea450c713c7
05:55:10  <Raynos>that's the first useful thing I can think of for widgets
05:55:46  <dominictarr>sure
05:56:12  <Raynos>so this is exciting
05:56:32  <Raynos>because var widget = Widget(); append(container, widget.elem) return widget; is annoying :D
05:56:46  <Raynos>also I've been thinking about this more.
05:57:12  <dominictarr>aha
05:58:53  <dominictarr>so… what have you been thinking?
05:59:16  <substack>I'm thinking I need to make fs.readFileSync() work in browserify already
06:00:14  <substack>Raynos: return widget.appendChild || widget.element && widget.element.appendChild
06:00:43  <substack>there's also insertBefore which is messy but sometimes you need
06:00:56  <Raynos>substack: https://github.com/Raynos/insert/blob/master/append.js
06:02:05  <Raynos>substack: http://dom.spec.whatwg.org/#parentnode
06:02:15  <Raynos>dominictarr: gisting
06:02:34  <dominictarr>I'd rather you tell me about it in english
06:06:09  <Raynos>:D
06:06:20  <Raynos>well it's exactly as I said yesterday.
06:06:33  <Raynos>A widget takes some representation of what needs to be rendered and generates a view for it
06:06:57  <dominictarr>aha
06:07:13  <dominictarr>okay, you can show me the code now
06:07:15  <Raynos>It then captures user input from the generated view and returns a streaming / reducible / event emitter representation of the user input and transforms it into a DOM agnostic thing
06:07:39  <Raynos>and it then returns those "events" / "stream" and view
06:07:40  <Raynos>https://gist.github.com/d9f6db8184a95bd52cf8
06:07:53  <Raynos>the only difference between today and yesterday is that I implemented some code in this style
06:08:03  <Raynos>and it works nicely
06:08:17  <Raynos>because it puts a box around the DOM.
06:08:39  <Raynos>emphasis being on input must map onto the DOM as cleanly as possible and DOM events must be transformed into logical events for your stuff as lightly as possible
06:09:49  <Raynos>this pattern works the same if you replace reducers implementation detail with event emitters or streams
06:10:54  <Raynos>substack: fs.readFileSync would be awesome for me
06:11:41  <Raynos>substack: the only other thing I need you to do is leak process.env.NODE_ENV into the bundle ( https://github.com/Raynos/browserify-server/blob/master/index.js#L25 )
06:12:51  <Raynos>also I should draw a picture
06:13:00  <Raynos>of how this changed from what I did before
06:15:17  <dominictarr>Raynos: cool. I think this pattern works well for UI->data bindings
06:15:50  <Raynos>it works well for bidirectional things
06:16:00  * ralphtheninjaquit (Ping timeout: 276 seconds)
06:16:36  <dominictarr>what is a bidirectional widget that makes sense like this?
06:16:37  <Raynos>lets say you have the bidirectional text editing thing
06:16:53  <Raynos>and you want to patch on the users name to the state change of the text
06:17:01  <Raynos>so that you can render history of text deltas
06:17:34  <dominictarr>in that case, you can do that by hooking into the model
06:17:36  <dominictarr>not the UI
06:17:39  <Raynos>with this pattern its `var text = TextWidget(); return map(text, function (ev) { ev.name = username })` instead of `var text = TextWidget(name)`
06:18:01  <dominictarr>for that sort of case you go ui(model) -> element
06:18:19  <Raynos>i did the latter before and pushed the state that's irrelevant about the ui into ui widget
06:19:00  <dominictarr>because which user is editing a thing is not necessarily related to that UI
06:19:06  <Raynos>exactly!
06:19:31  <Raynos>but i pushed it into the UI widget so it could do `model.set(uuid(), { text: changedText, name: userName })`
06:19:42  <Raynos>but maybe that was just me writing bad code
06:20:00  <dominictarr>?
06:20:31  <Raynos>well I have a TextWidget(feed) -> Element and I want it to add changes to the feed
06:20:44  <Raynos>I had no clean way of ensuring that changes on the feed had both the text and user name context
06:20:50  <dominictarr>that looks good
06:20:51  <Raynos>user name is a bad example because its a global
06:21:07  <dominictarr>the feed is a duplex stream?
06:21:18  <Raynos>so I implemented the widget as TextWidget(feed, userName)
06:21:24  <Raynos>lets imagine feed is instance of AppendOnly
06:21:56  <dominictarr>I would probably go somethnig like
06:22:00  <Raynos>now lets imagine the user can log out of the app and log in as another user without breaking the UI
06:22:06  <Raynos>then that userName thing has to be a stream now
06:22:11  <dominictarr>FeedWidget(feed, Template)
06:22:16  <Raynos>and TextWidget has to do crazy state dance about "what is current userName"
06:22:41  <dominictarr>where template returns and HTMLEelement/widget, that represents a particular item
06:23:00  <Raynos>Oh I see!
06:23:02  <dominictarr>the user name changes?
06:23:29  <dominictarr>So, in this case, I think i'd use one thing to update the feed
06:23:37  <dominictarr>and one thing to display it
06:23:41  <Raynos>yeah the TextWidget updates the feed
06:24:00  <Raynos>its a bi directional feed of the text in that widget for a collabartive text editing app
06:24:04  <dominictarr>so I'd have a MessageEntry widget that calls feed.push(...)
06:24:30  <dominictarr>and the FeedWidget would get triggered and render that item
06:24:31  <Raynos>well MessageEntry needs to do feed.push({ textDelta: delta, userWhomEdits: user })
06:24:37  <defunctzombie>substack: where is that server example for testling
06:24:40  <dominictarr>yes
06:24:54  <Raynos>but that's not what I want because MessageEntry shouldn't care about user
06:25:15  <Raynos>I want MessageEntry().pipe(map(function (ev) { ev.userWhomEdits = user; return ev})).pipe(feed)
06:25:46  <Raynos>i.e. the ability to move responsibility for unrelated shit up the scope
06:25:58  <dominictarr>so, you go MessageEntry(function (message) { feed.push({user: UN, message: message})
06:26:16  <Raynos>yes! that
06:26:17  <dominictarr>or, what you said
06:26:59  <dominictarr>or MessageEntry().on('message', function (mes) {...})
06:27:01  <Raynos>in this case MessageEntry(feed) still takes feed because it needs to update text your editing if text delta comes in because it's like r-edit
06:27:34  <dominictarr>that is strange behaviour for a chat widget
06:27:37  <substack>defunctzombie: https://github.com/substack/testling-server-example
06:27:38  <Raynos>so it takes input to render in it's UI widget and returns output that is a bunch of widget specific events / stream whatever
06:28:13  <defunctzombie>substack: is there a way to detect what browser I am running under?
06:28:42  <defunctzombie>I am trying to test something that should have different results in different browsers
06:28:42  <dominictarr>so, I think in cases that the widget creates a model part - like a stream or an event emitter
06:28:43  <Raynos>dominictarr: yes it is. I wasn't talking about chat widget. I was talking about document editing widget. which has TextEntry for editing text and FeedWidget for viewing history
06:29:34  <dominictarr>okay… so in that case, feed widget is a one way binding
06:30:26  <dominictarr>you should have a list of usernames -> source_ids and the feed history, then you can show blame
06:31:09  <Raynos>well that's a specific implementation detail of scuttlebutt
06:31:19  <Raynos>its probably easier to not rely on source_id and just put user details in message
06:31:47  <dominictarr>that would break r-edit
06:32:20  <dominictarr>you would have to fork r-edit to add that feature
06:33:03  <dominictarr>you are messing with stuff that is not part of the public api
06:33:18  <Raynos>True
06:33:25  <Raynos>but I'm trying to make a vague example :p
06:33:42  <Raynos>of a situation where you want to wrap a widget's generic events in more app specific ones
06:33:51  <dominictarr>And I'm trying to make your example realistic B)
06:33:55  <Raynos>im just bad of thinkign of examples
06:34:40  <Raynos>but the more you push app specific shit out of your widget and up to the widget creator's responsibility the modular and clean shit is.
06:34:52  <dominictarr>just think how would I build fackbook, twitter, trello, etc
06:34:57  <Raynos>also I implemented Set.every
06:35:31  <dominictarr>usually with widget frameworks, it's like here is 30 widgets! you life is easy!
06:35:38  <dominictarr>but that is wrong
06:35:42  <Raynos>agreed
06:35:45  <dominictarr>you need hundreds and hundreds
06:35:52  <Raynos>I want a widget to be an app specific encapsulation of the DOM
06:36:06  <dominictarr>… maybe not quite app specific
06:36:09  <Raynos>the reason it's app specific is not the JS
06:36:11  <Raynos>it's the HTML & CSS
06:36:15  <dominictarr>yeah
06:36:16  <Raynos>the HTML & CSS is very app specific
06:36:17  <dominictarr>agree
06:36:21  <Raynos>the JS is pretty generic
06:36:23  <dominictarr>that is the problem with HTML
06:36:32  <Raynos>gbut the nice thing is!
06:37:01  <Raynos>I actually do `module.exports = Widget(template, Person)`
06:37:19  <Raynos>so you could do `module.exports = Widget(myPersonTemplate, require("person-module"))`
06:38:05  <Raynos>and as long as there is a very thin contract between the template and the js module. i.e. "there are these classes in the DOM that work with my query selectors" or "there are these meta data-x properties in the template which I can bind data to" you can take generic modules and create specific html / css
06:38:37  <defunctzombie>substack: how would you test something like this? https://github.com/runningskull/browser-kthx
06:39:01  <defunctzombie>basically, want to see that the response is one thing when in IE 8 or so
06:39:06  <defunctzombie>and another when in different browsers
06:39:18  <defunctzombie>I can use useragent detection in the tests directly
06:39:21  <Raynos>defunctzombie: iframes :D
06:39:31  <defunctzombie>but was wondering if testling exposes the current browser in any way
06:39:37  <defunctzombie>Raynos: haha
06:39:46  <Raynos>your server starts x on port Y and your test opens iframe to testling:Y
06:40:13  <defunctzombie>browserling you mean
06:40:29  <defunctzombie>or testling as well I suppose
06:40:40  <Raynos>i mean testling
06:40:42  <Raynos>write an automated test
06:41:29  <defunctzombie>I look forward to the day when computers will test themselves
06:44:45  * defunctzombiechanged nick to defunctzombie_zz
06:45:39  <mikola>Latest package: https://github.com/mikolalysenko/bit-twiddle
06:45:51  <substack>defunctzombie_zz: nope there isn't anything to directly tell which browser is running aside from the UA
06:46:23  <substack>mikola: sweet! this is the best possible new years resolution too: https://0fps.wordpress.com/2013/01/15/new-years-resolution-post-more-stuff-on-npm/
06:46:33  <mikola>on the road to doing more geometry stuff in js
06:46:47  <mikola>substack: haha, thanks
06:48:34  <mikola>my next big project is to split this monstrosity up: https://github.com/mikolalysenko/TrimeshJS
06:48:42  <Raynos>dominictarr: I get it. be more verbose :p
06:49:12  <dominictarr>no, say what needs to be said
06:49:45  <substack>mikola: did you see the voxel drone demo? http://shama.github.com/voxel-drone/
06:49:51  <dominictarr>you need to explain what the pr actually does
06:49:56  <dominictarr>and why I should pull it
06:50:14  <dominictarr>don't expect someone to figure that out from reading your code
06:50:43  <dominictarr>that is way to much work, and you are already in a good position to explain it, because you just wrote it.
06:51:31  <Raynos>man I thought just adding tests to PR is good enough :p
06:51:37  <Raynos>I have to actually explain it aswell?!
06:51:42  <dominictarr>yes
06:52:20  <dominictarr>this is actually the easyiest part though, because you already know what it does
06:53:01  <substack>and if you can't explain something maybe it isn't narrow enough
06:54:23  <mikola>substack: Pretty cool! I've never tried AR drone before, but I imagine that something like this could be useful for trying out different commands
06:55:31  * dominictarr_joined
06:56:37  * dominictarrquit (Ping timeout: 246 seconds)
06:56:38  * dominictarr_changed nick to dominictarr
06:58:41  <dominictarr>reading code is hard work, so you have to convince me that it's worth my time
06:59:24  * wiwilliaquit (Ping timeout: 260 seconds)
07:04:21  * ralphtheninjajoined
07:06:00  <mikola>Ok, I'm going to bed
07:06:01  <mikola>bye
07:06:19  * gwenbellquit (Ping timeout: 260 seconds)
07:08:59  * fotoveritequit (Quit: fotoverite)
07:12:33  * mikolaquit (Ping timeout: 245 seconds)
07:16:13  <dominictarr>Raynos: https://github.com/dominictarr/crdt/pull/16#issuecomment-12307327
07:16:48  * ralphtheninjaquit (Ping timeout: 245 seconds)
07:17:56  <Raynos>domincitarr:
07:17:57  <Raynos>https://github.com/dominictarr/crdt/pull/16#issuecomment-12307353
07:18:22  <Raynos>dominictarr: It's weird to listen to you talking ( http://vimeo.com/56227230 ) in video and then have you talk to me about something unrelated in chat
07:21:25  <dominictarr>Raynos: a user SHOULD NOT use a stateful function as a fitler
07:21:50  <Raynos>dominictarr: agreed. but a function can have the same source code and not be stateful and still not be pure
07:21:59  <Raynos>i.e. referencing closure bound variables that are constant
07:22:10  <Raynos>i.e. using higher order functions to build sets
07:22:18  <dominictarr>yes, so we shouldn't cache the set by the source
07:22:21  <dominictarr>of the function
07:22:29  <Raynos>yes
07:22:32  <dominictarr>that is a bug
07:22:38  <Raynos>which means either the user passes a uuid() for caching
07:22:40  <Raynos>or no caching
07:22:50  <Raynos>no, not uuid() thats stupid
07:22:55  <Raynos>eitehr the user names the set or no caching
07:22:59  <dominictarr>I will merge this
07:23:02  * thatguydanquit (Ping timeout: 255 seconds)
07:23:48  <dominictarr>but can you add a thing that says not to use stateful functions in filters to the readme, and then i'll merge
07:24:06  <Raynos>:D
07:24:41  <Raynos>btw !
07:24:43  <Raynos>Rethinkdb
07:25:01  <dominictarr>yeah, I've had a look at that
07:25:09  <Raynos>has this database engine where you pass a filter function as like function (a, b) { return a.plus(b) }
07:25:27  <Raynos>and it calls your function with two DBVar objects and you return a DBQuery object
07:25:30  <Raynos>and it then runs that!
07:25:37  <Raynos>now you can imagine a userland module
07:25:41  <dominictarr>I don't think they are rethinking radically enough
07:25:42  * fotoveritejoined
07:25:59  <Raynos>that takes function (a, b) { return a + b } and parse the AST and either throws or generates a valid DBQuery object
07:26:29  <Raynos>The set of all functions that can generate a valid DBQuery object should be what you use filters for! although fuck closure bound variables :/
07:26:37  <Raynos>blargh
07:26:44  <dominictarr>hmm, so to turns javascript into SQL or something?
07:27:07  <Raynos>theres no way to cleanly close over constant values and still do AST parsing to generate a DBQuery
07:27:21  <dominictarr>that is an interesting idea, but it's closure bound vars are too useful
07:27:33  <dominictarr>it means you get to use require if you want
07:27:47  <Raynos>Added thing to README
07:28:08  <Raynos>Oh I know
07:28:16  <Raynos>it should AST parse
07:28:21  <Raynos>build up a list of gaps
07:28:23  <Raynos>CALL the function
07:28:25  <dominictarr>merging
07:28:32  <Raynos>and fill the gaps with the values of the closure bound variables from calling it
07:29:08  <Raynos>and then you have a way to check whether it's a pure function or a pure function that closes over constant values!
07:29:18  <dominictarr>Raynos: set caching test fails
07:29:22  <Raynos>:(
07:29:39  * gwenbelljoined
07:30:26  <Raynos>fixed PRing
07:30:35  <Raynos>added commit
07:31:38  <dominictarr>great, merging
07:32:27  <dominictarr>[email protected]
07:33:17  <Raynos>what about Set.every?
07:39:57  * AvianFluquit (Remote host closed the connection)
07:40:17  <Raynos>dominictarr: btw if your interested in rethinkdb ( https://github.com/rethinkdb/rethinkdb/issues/221 )
07:40:28  <Raynos>pitch in 2 cents about their API surface
07:40:44  * dominictarr_joined
07:40:53  <Raynos>the rethinkdb map reduce thing is interesting
07:40:58  * dominictarrquit (Ping timeout: 245 seconds)
07:40:59  * dominictarr_changed nick to dominictarr
07:41:06  <Raynos>they basically say "reduce is commutative. It's a merge function"
07:41:28  <Raynos>they also say the reduce is function(Type, Type) -> Type
07:41:44  <Raynos>I like the idea of map-merge
07:42:44  <dominictarr>yeah, that is like in monge
07:42:46  <dominictarr>mongo
07:43:05  <dominictarr>that approach is definately easier to implement in the database
07:43:13  <Raynos>true actually
07:43:21  <dominictarr>because you push those expectations to the user
07:43:21  <Raynos>why did you not choose that approach?
07:43:26  <dominictarr>I did
07:43:35  <Raynos>i thought you did something more complex
07:43:38  <dominictarr>no
07:43:58  <dominictarr>oh… you have merge(type, type, group)
07:43:59  <Raynos>oh I see
07:44:07  <dominictarr>which just tells you what the key is currently
07:44:22  <Raynos>why is it called reduce instead of merge?
07:44:24  <dominictarr>I havn't used that, but it might be useful
07:45:01  <dominictarr>yes, merge is better
07:45:31  <dominictarr>I was influenced by couch and mongo calling it reduce
07:45:42  <dominictarr>mongo works like this too
07:45:52  <dominictarr>right? it just doesn't explain it as well
07:47:24  <Raynos>yes mongo works like that too
07:47:33  <Raynos>array of values all of same shape
07:47:36  <Raynos>return single value of that shape
07:47:52  <substack>it's odd that document dbs don't implement hash joins too
07:49:24  <Raynos>rethinkdb implements joins
07:49:30  <Raynos>not sure whether its a hash join
07:49:59  <substack>hash and merge joins are the fast ones so probably
07:51:54  <Raynos>aha substitution.
07:52:07  <Raynos>that's what I'm looking for
07:52:18  <Raynos>substack: do you have a module for ast tree substition of free variables?
07:53:08  <dominictarr>we also need a fanout module for level db
07:53:15  <dominictarr>so, you can materialize a join
07:53:25  <dominictarr>useful for newsfeeds
07:53:50  <dominictarr>R
07:53:57  <dominictarr>relocating brb
07:53:59  * dominictarrquit (Quit: dominictarr)
08:10:22  * dguttmanquit (Quit: dguttman)
08:14:08  * fotoveritequit (Ping timeout: 256 seconds)
08:21:58  <Raynos>http://stackoverflow.com/questions/14353978/how-to-parse-pure-functions
08:27:09  * ryan_stevensjoined
08:51:41  * dominictarrjoined
08:51:50  <dominictarr>back
08:54:42  <Raynos>dominictarr: http://stackoverflow.com/questions/14353978/how-to-parse-pure-functions
08:57:52  <dominictarr>Raynos: doing that should be fairly straightforward
08:58:05  <Raynos>I can't imagine how
08:58:18  <Raynos>you would do it without fucking up at higher complexity functions
08:58:24  <Raynos>like functions that are not in the domain of integers
08:58:40  <dominictarr>https://github.com/substack/scoper
08:58:58  <dominictarr>that has a different focus, but does similar stuff
08:59:35  <Raynos>dominictarr: but you can't do that. You can't convert the function to source
08:59:53  <Raynos>it closes over variables and I want to know the value of the constants in the closure scope
09:00:28  <dominictarr>you'd only have to change scoper a bit to make it work
09:00:39  <dominictarr>it's in the same ballpark, at least
09:01:19  <dominictarr>see this guy's code too https://github.com/CrypticSwarm?tab=repositories
09:01:25  <Raynos>all scoper does is parse and transform source
09:01:58  <dominictarr>so, you want to get the variables that are not defined in the function, right?
09:02:41  <dominictarr>that is a simple matter of traversing the ast and finding functions that are not arguments or have vars
09:02:52  <Raynos>yes
09:02:57  <Raynos>but then I dont know how to get their value
09:03:18  <Raynos>i need their value because i basically want to serialize and deserialize the function and have it work the same
09:03:47  <dominictarr>right… so you'd need access to the outer scope
09:04:48  <dominictarr>if you have serialized it, it won't work anyway, because the outer functions will not be there
09:05:08  <dominictarr>unless you transform the whole file… like in scoper
09:05:10  <Raynos>maybe I should not optimize for this edge case :P
09:05:22  <Raynos>oh that's interesting transforming the entire file
09:05:36  <Raynos>but then it cant be done at run-time
09:05:46  <Raynos>Unless you have a JS VM in JS!
09:06:06  <Raynos>but you still need the outer scope :(
09:06:10  <Raynos>and the source code
09:06:26  * ryan_stevensquit (Remote host closed the connection)
09:06:47  <dominictarr>this is all black magic, and best avoided
09:07:40  <Raynos>agreed
09:07:45  <Raynos>its best to have the API that answer has
09:07:53  <Raynos>static analysis of source and pass in any closure variables
09:08:23  <Raynos>which I think is exactly what mongodb does :p
09:09:47  <dominictarr>or… just eval in a scope that has specific vars, like emit, or require
09:12:04  * fotoveritejoined
09:13:57  * thatguydanjoined
09:20:20  * fotoveritequit (Ping timeout: 248 seconds)
09:33:03  * ITproquit (Read error: Connection reset by peer)
09:33:25  * ITprojoined
09:46:45  * fotoveritejoined
09:56:04  * fotoveritequit (Ping timeout: 248 seconds)
10:00:53  * saijanai_quit (Read error: Connection reset by peer)
10:02:32  * saijanai_joined
10:22:27  * fotoveritejoined
10:30:41  * fotoveritequit (Ping timeout: 255 seconds)
10:37:10  * jibayjoined
10:41:54  <dominictarr>hij1nx:
10:42:00  <dominictarr>hij1nx: ping?
10:53:24  * ins0mniajoined
10:57:11  * fotoveritejoined
11:05:33  * fotoveritequit (Ping timeout: 245 seconds)
11:08:10  <guybrush_>http://youtu.be/KJo12Hz_BVI :D
11:21:27  <dominictarr>jjjjohnnny: interesting idea: betting as contract
11:21:43  <dominictarr>lets say I take out a bet with you that you can't make me a website
11:21:58  <dominictarr>so, all you have to do, is make the website, and you win the bet
11:32:17  * fotoveritejoined
11:37:23  * ins0mniaquit (Ping timeout: 255 seconds)
11:41:18  * fotoveritequit (Ping timeout: 276 seconds)
11:43:46  <substack>http://substack.net/projects/pricing-widget/basic/
11:43:50  <substack>http://substack.net/projects/pricing-widget/browserling/
11:45:00  * thatguydanquit (Remote host closed the connection)
11:45:14  * thatguydanjoined
11:45:25  * thatguydanquit (Client Quit)
11:57:11  * No9quit (Ping timeout: 255 seconds)
11:58:48  * No9joined
12:07:35  * fotoveritejoined
12:16:24  * fotoveritequit (Ping timeout: 264 seconds)
12:26:13  <substack>https://github.com/substack/pricing-widget
12:40:33  <dominictarr>substack: hey, is there a code coverage tool compatible with tape?
12:41:16  <dominictarr>I want to use it just to see what code is getting hit… for bebugging
12:41:57  * fotoveritejoined
12:42:00  <substack>I don't know of any off-hand
12:42:13  <substack>I haven't done coverage for a while
12:49:51  <dominictarr>I want something where you log your state, and then change code, and you see the difference in state
12:50:24  * fotoveritequit (Ping timeout: 260 seconds)
12:51:02  <dominictarr>showing if something happened in a different order, or if something was missed, you can easily see
12:53:30  <dominictarr>… maybe you could do a basyian thing where it logs state snapshots/codepaths runs a bunch of times
12:53:39  <dominictarr>and then detects unlikely changes
12:54:18  <dominictarr>so you can say "change X caused Y to happen 80% more"
12:54:38  <substack>hah
12:56:17  <dominictarr>code coverage sort of thing could be useful here, because often you are trying to discover "what didn't happen that I thought should happen"
12:56:58  <dominictarr>code coverage isn't quite enough on it's own, because it might be code coverage for a particular object instance.
12:57:25  <rolnaaba>You could use a tool like statsd, and see when certain actions have different effects ont he system over time
12:57:42  <rolnaaba>on the *
12:57:50  <dominictarr>statsd? is that for IO stuff?
12:59:04  <dominictarr>found it
12:59:37  <dominictarr>hmm, no I think this is a different problem.
13:10:19  * dominictarrquit (Read error: Connection reset by peer)
13:10:38  * dominictarrjoined
13:16:52  * fotoveritejoined
13:22:02  * rolnaabaquit (Read error: Connection reset by peer)
13:22:47  * mirkokjoined
13:23:26  * mirkokquit (Client Quit)
13:23:48  * rolnaabajoined
13:26:07  * dominictarr_joined
13:26:48  * dominictarr_quit (Client Quit)
13:28:04  * dominictarrquit (Ping timeout: 256 seconds)
13:50:32  * ralphtheninjajoined
13:57:17  * dominictarrjoined
13:58:17  * dominictarrquit (Client Quit)
14:16:49  * mirkokjoined
14:23:40  * exit2joined
14:24:54  * mikolajoined
14:28:14  * dominictarrjoined
14:29:45  * mirkokquit (Quit: mirkok)
14:37:01  <hij1nx>dominictarr: pong
14:37:20  <dominictarr>hij1nx: hang on in the middle of a call
14:37:28  <hij1nx>dominictarr: kk
14:37:46  * mirkokjoined
14:42:25  <hij1nx>dominictarr: possibly not what you pinged me about, but wrt coverage, i think what you are really looking for is dtrace!
14:58:28  * yorickjoined
14:58:28  * yorickquit (Changing host)
14:58:28  * yorickjoined
15:05:38  * ins0mniajoined
15:06:57  * dominictarr_joined
15:07:01  * dominictarrquit (Read error: Connection reset by peer)
15:07:02  * dominictarr_changed nick to dominictarr
15:15:34  * defunctzombie_zzchanged nick to defunctzombie
15:15:58  <dominictarr>defunctzombie: what is your bitcoin exchange?
15:16:08  <defunctzombie>dominictarr: bitfloor.com
15:16:12  * cianomaidin_joined
15:16:16  <dominictarr>thanks
15:16:29  * mariusursachejoined
15:23:20  <yorick>CoverSlide: you're everywhere!
15:35:53  * mikolaquit (Ping timeout: 245 seconds)
15:47:54  <defunctzombie>dominictarr: where are you now?
15:49:07  * dominictarrquit (Quit: dominictarr)
16:00:54  * tomshredsjoined
16:08:12  * dguttmanjoined
16:12:15  * tomshredsquit (Quit: Linkinus - http://linkinus.com)
16:30:40  * mikolajoined
16:44:22  * gwenbellquit (Read error: No route to host)
16:45:31  * dominictarrjoined
16:57:27  * sorensen_joined
16:57:50  * sorensen_quit (Client Quit)
17:08:58  <rowbit>/!\ ATTENTION: (default-local) [email protected] successfully signed up for developer browserling plan ($20). Cash money! /!\
17:08:58  <rowbit>/!\ ATTENTION: (default-local) paid account successfully upgraded /!\
17:09:16  <defunctzombie>\o
17:09:19  <defunctzombie>\o/
17:09:36  <defunctzombie>substack: can I do range stuff on testling ci ?
17:11:07  * AvianFlujoined
17:11:20  <pkrumins>not yet
17:11:28  <defunctzombie>ah
17:11:47  <pkrumins>problem is the ranges have to be automated as new browsers get added
17:13:48  <defunctzombie>pkrumins: the allowed ranges are passed into the function
17:14:14  <defunctzombie>so wherever that list of supported browsers for the browsers.json url comes from
17:14:32  <defunctzombie>the browsers are not hard coded into the module
17:15:27  <defunctzombie>pkrumins: do you guys have https?
17:15:30  <pkrumins>i remember i saw version though
17:15:47  <pkrumins>like 1, 5, 14, 15, 20, 21, 22 somewhere
17:16:01  <pkrumins>oh https
17:17:19  <pkrumins>dont have it yet
17:27:53  * defunctzombiechanged nick to defunctzombie_zz
17:29:45  <pkrumins>http://www.catonmat.net/blog/announcing-testling-ci/
17:32:47  * tphummeljoined
17:36:57  <fotoverite>no
17:37:04  <fotoverite>wait wrong window
17:47:28  * ryanclosnerjoined
17:48:05  <ryanclosner>mbalho: question on the generate function in voxel.
17:48:52  <ryanclosner>mbalho: it takes a two arrays (low and high). are these related to the chunk the voxel is associated with?
17:51:00  <CoverSlide>yorick: I am everywhere and nowhere.
17:51:33  <yorick>CoverSlide: how did you find me? why you?
17:52:36  <CoverSlide>yorick: it is not mine to ask, only to follow
17:54:16  <yorick>CoverSlide: what?
17:54:22  <CoverSlide>exactly
17:54:40  <CoverSlide>I just follow smart people around, hoping to become smarter in the process
17:55:27  <yorick>I'm a smart person? whoa.
17:58:10  <CoverSlide>I don't know , probably smarter than me
17:59:12  <CoverSlide>that's the main criteria
18:01:08  * ryan___joined
18:01:08  * ryanclosnerquit (Quit: leaving)
18:01:19  * ryan___changed nick to rclosner
18:02:11  <yorick>CoverSlide: I don't know, we have a lot of channels in common
18:02:23  <CoverSlide>i have 29 channels open
18:02:31  <CoverSlide>i have a lot of channels open with lots of people
18:02:44  <CoverSlide>s/open/in common/
18:02:51  <exit2>jesus 29 channels
18:02:54  <pkrumins>testling-ci is hacker news front page! http://news.ycombinator.com
18:02:58  <pkrumins>give it more uvpotes guys!
18:03:05  * shamajoined
18:03:12  <CoverSlide>i idle on some, troll in others
18:03:22  * cianomaidin_quit (Quit: cianomaidin_)
18:05:39  <exit2>CoverSlide: I mostly troll
18:07:24  <CoverSlide>vengeance for zul'jin!
18:07:33  * devaholicjoined
18:14:32  * dominictarrquit (Quit: dominictarr)
18:17:23  * wiwilliajoined
18:28:22  * defunctzombie_zzchanged nick to defunctzombie
18:32:42  <defunctzombie>pkrumins: nice
18:50:01  * cianomaidin_joined
19:08:07  <defunctzombie>isaacs:
19:08:11  <defunctzombie>ping
19:28:09  <isaacs>defunctzombie: pong
19:39:32  * cianomaidin_quit (Quit: cianomaidin_)
19:45:37  <defunctzombie>isaacs: https://github.com/isaacs/npm/issues/3063
19:45:44  <defunctzombie>ran into that earlier today
19:46:13  <isaacs>defunctzombie: well, that's bizarre
19:46:16  <defunctzombie>the fucking mocha broke something and I had to pin the version locally, but my globally installed version kept running
19:46:26  <defunctzombie>yea, I agree
19:46:32  <defunctzombie>I am not even sure if it is a regression
19:46:38  <defunctzombie>or if it was just never caught before
19:46:56  <defunctzombie>I verified it by having "mocha --version" be my test script
19:47:13  <defunctzombie>to see what was actually being run
19:47:42  <defunctzombie>it is possible it was something with mocha (but seemed more likely that it was just a lookup error when running through npm)
19:48:17  <isaacs>defunctzombie: it's a bug alright
19:49:15  <isaacs>defunctzombie: fixed on c716ed61d9feb5d65d7db46a2709b9f0bd2d9354
19:49:38  <defunctzombie>isaacs: nice :)
19:51:18  * mikolaquit (Ping timeout: 245 seconds)
19:57:15  * No9quit (Ping timeout: 276 seconds)
19:57:59  * No9joined
19:59:02  <Raynos>defunctzombie: never do global installs !
19:59:11  <Raynos>Add `./node_modules/.bin` to your PATH
20:02:06  * ryan_stevensjoined
20:11:15  <CoverSlide>actually, that's not a bad idea
20:11:18  <pkrumins>ryan_stevens: http://www.catonmat.net/blog/announcing-testling-ci/
20:11:44  <CoverSlide>isaacs: any chance npm explore can do this?
20:12:01  <mbalho>12:02 < mrdoob> mbalho, voxel.js is looking pretty great
20:12:04  <mbalho>\o/
20:12:27  <CoverSlide>haha awesome
20:12:39  * ITproquit (Ping timeout: 260 seconds)
20:12:46  <isaacs>CoverSlide: do what?
20:12:52  <CoverSlide>he needs to add you to his examples thing
20:13:12  * ITprojoined
20:13:33  <CoverSlide>isaacs: i'm in a project, i want to use binary versions of the installed modules, so npm explore subshell to add .bin to PATH?
20:14:06  <isaacs>oh, that
20:16:15  * nk109joined
20:16:21  <isaacs>sure
20:16:34  <isaacs>CoverSlide: i kinda alwyas meant to add `npm exec` to run something as if it was a script
20:16:57  <isaacs>CoverSlide: so you could do `npm exec bash` if you wanted to hop into a shell where node_modules/.bin is first int eh PATH
20:20:20  <defunctzombie>Raynos: that doesn't make sense hahaha what would be the ./node_modules that I would use?
20:20:31  <defunctzombie>Raynos: a global install is just a node_modules folder that is in my home dir
20:20:38  <Raynos>`npm i mocha -S` ./node_modules/.bin/mocha
20:20:42  <defunctzombie>I like it for command line tools and such
20:20:51  <Raynos>now if `./node_modules/.bin` is in $PATH
20:20:53  <defunctzombie>Raynos: but what is the '.' in your path?
20:20:57  <Raynos>then you can use local installed dependencies as CLI
20:21:00  <defunctzombie>oh, I see
20:21:08  <defunctzombie>bah, I don't like that
20:21:13  <defunctzombie>for stuff like localtunnel
20:21:15  <defunctzombie>and docserv
20:21:16  <Raynos>Actually `node_modules/.bin`
20:21:20  <defunctzombie>I use those as programs
20:21:21  <Raynos>its fantastic for what I do
20:21:26  <Raynos>I use testem in many different projects
20:21:30  * fotoveritequit (Quit: fotoverite)
20:21:31  <Raynos>and each one has a different version
20:21:38  <Raynos>and each one has a different local testem config file
20:21:42  <Raynos>that only works with that version
20:21:49  <Raynos>if I had a global testem I would be fucked
20:21:51  <defunctzombie>yea, that is cause testem is overkill :p
20:21:53  <Raynos>but a local one is fantastic
20:21:57  <defunctzombie>but yes, I can understand that
20:22:00  <defunctzombie>same iwth mocha
20:22:02  <Raynos>testem is overkill but it's besides the point
20:22:06  <defunctzombie>hahaha
20:22:07  <Raynos>local deps are awesome
20:22:12  <Raynos>some stuff should be global for convenience
20:22:14  <defunctzombie>local deps yea
20:22:18  <defunctzombie>but these are not deps
20:22:24  <defunctzombie>and yes, I agree
20:22:30  <defunctzombie>mocha and testem could be deps
20:22:33  <Raynos>:3
20:22:42  <defunctzombie>I have it installed globally for other stuff/reasons/testing etc
20:22:57  <defunctzombie>not because I tend to use it that way, I tend to just use npm test
20:24:21  <defunctzombie>Raynos: imma try to get around to npm-css this week
20:24:40  <Raynos>I've actually gone a different approach recently but I'm not sure whether it's better
20:24:43  <defunctzombie>really want it to finish out my widget exploration stuffs
20:24:53  <defunctzombie>what is the approach?
20:24:56  <Raynos>document.head.appendChild(Style(require("module/style.css")))
20:25:17  <Raynos>defunctzombie: did you see https://gist.github.com/d9f6db8184a95bd52cf8 ?
20:25:52  <defunctzombie>Raynos: not sure I like that cause one of the aspect of npm-css is opt in/out of styles
20:26:07  <Raynos>no you misunderstand
20:26:08  <defunctzombie>Raynos: yea, I did, but that is much more high level than what I am targeting
20:26:11  <Raynos>you load a modules style and inject it
20:26:18  <defunctzombie>oh
20:26:25  <Raynos>the module doesnt bootstrap its own style into your DOM
20:26:41  <defunctzombie>meh, I would prefer to have the style upfront
20:26:45  <defunctzombie>I gotcha
20:26:57  <Raynos>well its whether you want the JS or CSS flow tbh
20:27:03  <Raynos>tradeoffs everywhere ;)
20:27:03  <defunctzombie>yes
20:27:06  <defunctzombie>I agree
20:27:17  <defunctzombie>style is one of those strange things
20:27:35  <defunctzombie>right now I am leaning towards the npm-css approach
20:27:47  <defunctzombie>since it currently seems easier
20:28:02  <defunctzombie>and more typical of how you might expect to deal with style sheets :/
20:28:07  * ryan_stevensquit (Remote host closed the connection)
20:28:57  <defunctzombie>and if I can just drop it into my webstack, then I don't have to keep doing js to bring in widget styles and such
20:29:08  * mikolajoined
20:29:16  <Raynos>defunctzombie, chrisdickinson: do you have a module for mouseenter / mouseleave ?
20:29:38  <defunctzombie>Raynos: sorta
20:30:01  <defunctzombie>Raynos: actually, no, not yet
20:30:05  <defunctzombie>https://github.com/shtylman/dom/blob/master/index.js#L305
20:30:30  <defunctzombie>I have it listed as a todo and eventually a separate file/module maybe
20:31:03  <Raynos>>_<
20:31:16  <Raynos>ok ill go figure out how to implement it myself
20:31:20  <defunctzombie>cool
20:31:24  <defunctzombie>let me know once you do :)
20:31:38  <defunctzombie>jquery source might be of help (doubtful but possible)
20:31:44  <defunctzombie>they synthesize the event as well
20:38:09  * cianomaidin_joined
20:44:25  * gwenbelljoined
20:44:29  * gwenbell_joined
20:45:21  * yorickquit (Remote host closed the connection)
20:51:54  * rclosnerquit (Remote host closed the connection)
20:55:41  <shama>woohoo I got a camera working on the voxel drone
20:56:37  <mbalho>whaaa
20:56:53  <mbalho>oh thats awesome
20:57:18  <shama>going to turn it into another module and polish it up
21:02:02  * cianomaidin_quit (Quit: cianomaidin_)
21:08:48  * mikolaquit (Ping timeout: 245 seconds)
21:15:23  * mikealjoined
21:22:09  * mirkokquit (Quit: mirkok)
21:23:23  * mikolalysenkojoined
21:23:56  <mikolalysenko>Ok, semiserious question here: Why does AMD exist, and why are people using it?
21:24:24  <mikolalysenko>(by AMD I mean the RequireJS Aynschronous Module Definition system)
21:25:47  * cianomaidinjoined
21:32:21  <defunctzombie>mikolalysenko: because they don't realize there is something better
21:32:35  <defunctzombie>AMD filled a certain use case people had years ago
21:32:57  <defunctzombie>and some people bought into it without realizing they were solving a tooling problem with manual labor and crappy syntax
21:33:35  <defunctzombie>mikolalysenko: js by itself has no "native" concept of modules, so every solution is one that is presented by a third party
21:33:43  <mikolalysenko>of course
21:33:45  <defunctzombie>AMD is just one of those solutions, like commonjs
21:33:50  <mikolalysenko>but I was wondering what the history of AMD was
21:34:00  <mikolalysenko>as far as I understand it, it was created AFTER CommonJS
21:34:19  <mikolalysenko>which blows my mind, since as far as I can tell it is worse in every possible way...
21:34:48  <Raynos>mikolalysenko: it allows you to do modules without any kind of local tooling. It's all based on script tags and javascript in browsers
21:34:56  <Raynos>the history of AMD is dojo
21:35:33  <mikolalysenko>Raynos: Ok, that makes a little bit of sense
21:35:49  <mikolalysenko>though I don't know what you mean by dojo
21:36:19  <defunctzombie>mikolalysenko: dojo is a client side framework
21:36:23  <mikolalysenko>(of course you could also do CommonJS without tooling too, but it would be pretty slow)
21:36:49  <mikolalysenko>is it any good?
21:36:55  <defunctzombie>I dunno
21:36:58  <defunctzombie>I haven't used it
21:37:07  <defunctzombie>it is one of those do everything frameworks iirc
21:37:13  <mikolalysenko>yeah...
21:37:20  <defunctzombie>http://dojotoolkit.org/
21:37:24  * ins0mniaquit (Ping timeout: 264 seconds)
21:37:34  <mikolalysenko>I think absent a common module system (like npm) the tendency is always towards more features in each library
21:37:50  <mikolalysenko>(which I personally find a little stupid, but that is my opinion)
21:38:21  <rowbit>/!\ ATTENTION: (default-local) paid account successfully upgraded /!\
21:38:21  <rowbit>/!\ ATTENTION: (default-local) [email protected] successfully signed up for developer browserling plan ($20). Cash money! /!\
21:39:13  <pkrumins>\o/
21:39:34  <brianloveswords>Does anyone know how to get openssl on OS X to list all public key algorithms? `openssl list-public-key-algorithms` doesn't work for me.
21:39:37  <defunctzombie>mikolalysenko: correct, without a module system, you lean towards globals and everything in one file
21:40:24  <defunctzombie>brianloveswords: worked for me
21:40:46  <brianloveswords>defunctzombie: did you replace/upgrade your version of openssl?
21:41:01  <defunctzombie>who knows :) I have macports
21:41:07  <brianloveswords>I figured out the problem, that command was added in 1.0, my default openssl is 0.9.8r
21:41:25  <brianloveswords>Guess this is good a reason as any to upgrade!
21:42:30  <mikolalysenko>ok, so outside of dojo who is promoting using amd today?
21:42:46  <mikolalysenko>because I see it get mentioned all the time when people talk about JS module systems
21:43:17  <defunctzombie>mikolalysenko: anyone who doesn't know any better
21:43:28  * nk109quit (Quit: Computer has gone to sleep.)
21:43:36  <defunctzombie>mikolalysenko: it isn't some evil sin to promote it, they may have just not learned about the other tools
21:44:12  <defunctzombie>now if someone has learned about the other ways and still thinks it is better, then they delusional ;)
21:44:12  <mikolalysenko>defunctzombie: That is basically the conclusion I came to as well, or said in other words the popularity of AMD is really a product of ignorance
21:44:46  <mikolalysenko>Well, I read this thing and it made my head hurt: http://requirejs.org/docs/whyamd.html
21:45:00  <defunctzombie>in node we are a bit isolated from python and ruby
21:45:09  <defunctzombie>so we don't do as much to promote our tools to those crowds
21:45:18  <mikolalysenko>I see
21:45:29  <defunctzombie>and those crowds see many of our tools as just node specific and don't realize it applies to JS in general
21:45:36  <mikolalysenko>well, I don't really have much of a web development background so I am still trying to learn the history
21:46:08  <mikolalysenko>but that article (and RequireJS in general) seem pretty harmful
21:46:24  <mikolalysenko>since the first thing you see when you look for how "require in a browser" is RequireJS
21:46:30  <defunctzombie>mikolalysenko: yes, it is imho
21:46:37  <mikolalysenko>and RequireJS doesn't even implement require properly!
21:46:38  <defunctzombie>and some of their concerns were "valid"
21:46:45  <defunctzombie>but they were just not htinking outside the box
21:47:00  <defunctzombie>I write the type of JS that I want to make my life easier
21:47:09  <defunctzombie>and solve the remaining issues with better tools and environments
21:47:25  <mikolalysenko>that seems like a sane approach, and one which I aspire to as well
21:48:09  <defunctzombie>js has always been about the browser
21:48:19  <mikolalysenko>absolutely
21:48:21  <defunctzombie>with very few good ways to write it like we write other languages
21:48:30  <mikolalysenko>again, agreed
21:48:31  <defunctzombie>so changing that approach takes time, education, and promotion
21:49:03  <mikolalysenko>again sensible
21:49:13  <mikolalysenko>I am thinking now that I should probably write a blog post about this...
21:49:47  <Raynos>mikolalysenko: http://requirejs.org/docs/history.html best I could find
21:49:55  <Raynos>theres a better article about the history of AMD
21:50:24  <defunctzombie>mikolalysenko: http://shtylman.com/post/the-copy-and-paste-virus/
21:50:49  <defunctzombie>you could outline the history behind it, what has changed
21:50:56  <defunctzombie>and some up and coming approaches
21:51:35  <defunctzombie>"I originally wanted something that would work with CommonJS modules, but those modules seemed to be structured assuming a synchronous module loader" structured that way yes, but how it can be implemented, no
21:51:59  <defunctzombie>the awesome thing about basic commonjs require style is that you can instrument it easily
21:52:04  <Raynos>defunctzombie: synchronous module loader requires an analyser
21:52:14  <defunctzombie>whenever you make something easy to instrument, there are very few limitations
21:52:21  <Raynos>AMD can be done WITHOUT parsing source code ever
21:52:33  <Raynos>that's the only advantage
21:52:44  <mikolalysenko>Raynos: that is a good point
21:53:07  <defunctzombie>yep, and as time goes on I feel that is less and less important
21:53:22  <mikolalysenko>again, I agree
21:53:27  <Raynos>npm i http://stackoverflow.com/a/6131052/419970 should just work
21:53:36  <Raynos>why can't I install code from stackoverflow answers :(
21:53:50  <CoverSlide>hahaha
21:53:53  <Raynos>im not saying AMD is good
21:54:02  <Raynos>im saying it makes different trade offs
21:54:18  <Raynos>oh the other advantage of amd!
21:54:23  <Raynos>is you can edit the source code over sftp
21:54:26  <Raynos>in production
21:54:31  <Raynos>without rebuilding / compiling :D
21:54:34  <mikolalysenko>Raynos: Right. I also think AMD is pretty bad, I just want to try to understand the other side's arguments better
21:54:35  <defunctzombie>yes! that is the best
21:54:44  <defunctzombie>cause we know that will never lead to failure haha
21:54:49  <Raynos>NEVER
21:54:53  <Raynos>i always code over sftp
21:54:58  <defunctzombie>Raynos: yea, basically mousenter is done with "delegated" events
21:55:29  <mikolalysenko>well, maybe someone finds that useful
21:56:08  <Raynos>well the other thing about AMD
21:56:14  <Raynos>is that it fuckign works over file:// uris
21:56:16  <Raynos>out of the box
21:56:23  <Raynos>AMD is about tooling minimalism
21:56:27  <Raynos>and environment minimalism
21:56:35  <Raynos>and the trade-off is bullshitting the fuck out of your code
21:56:42  <mikolalysenko>yeah, you brought that point up earlier
21:57:31  <mikolalysenko>another related question: are there any big repositories of libraries written using amd?
21:57:40  <mikolalysenko>(other than dojo)
21:57:45  <Raynos>there are a few floating around
21:57:52  <Raynos>jam is an AMD package manager
21:57:56  <Raynos>I think bower might have AMD in it
21:58:10  <Raynos>npm probably has more AMD modules in it then both jam and bower combined xd
21:58:40  <mikolalysenko>yeah, I'm looking at it and it seems pretty anaemic
21:59:04  <mikolalysenko>also for a group of people so opposed to tooling, it seems to require a lot of tooling :)
22:00:05  <mikolalysenko>ok another historical/cultural question: are there other big options out there besides commonjs/amd?
22:00:21  <mikolalysenko>I know there are javascript compiler frameworks like Google's closure but I haven't used them before
22:00:33  <mikolalysenko>how do they handle modules?
22:00:47  <mbalho>mikolalysenko: google closure modules are kind of crazy
22:00:57  <mbalho>mikolalysenko: lots of OOP influence
22:01:04  <mbalho>mikolalysenko: makes JS feel like Java
22:01:36  <mbalho>mikolalysenko: and then they have a level of annotation you can put in your code to enable 'advanced compilation'
22:01:48  <mbalho>mikolalysenko: but uglifyjs comes close enough without any of that stuff for just file size reduction
22:01:57  <mbalho>mikolalysenko: nice to see you in here BTW! this is @maxogden
22:02:23  <mikolalysenko>mbalho: cool! nice to meet you! good work on voxeljs!
22:02:36  <mbalho>mikolalysenko: thanks! and thanks for all the blog posts
22:02:51  <mbalho>mikolalysenko: (And code)
22:03:02  <mbalho>mikolalysenko: another newer project is https://github.com/component
22:03:15  <mbalho>mikolalysenko: which is by https://github.com/visionmedia
22:03:30  <mikolalysenko>you're welcome! I'm currently working on trying to bring more of my stuff over to CommonJS/npm since it seems like a better way to share and reuse code
22:03:36  <mbalho>mikolalysenko: awesome
22:03:56  <CoverSlide>component / bower are just library repositories, really, not really package mangement / bundling
22:04:07  <CoverSlide>they just help you find and download libraries
22:04:13  <defunctzombie>component is a good idea but not a good execution imho
22:04:26  <mikolalysenko>ok, so another question about closure: does it really work?
22:04:39  <CoverSlide>lots of people use closure
22:04:41  <mikolalysenko>as in can it actually optimize your javascript's performance?
22:04:50  <defunctzombie>the compiler? or closure?
22:04:51  <CoverSlide>probably
22:04:58  <mikolalysenko>the compiler
22:05:18  <mikolalysenko>I'd be interested to see if it can make your code run demonstrably faster
22:05:24  <defunctzombie>mikolalysenko: depends on the js and optimization, but yes, if done perfectly correct it will improve some things, but not that much
22:05:27  <CoverSlide>it optimizes load time, it probably otimizes some code. shortening variable names probably provides a minor performance gain
22:05:28  <mbalho>https://developers.google.com/closure/compiler/docs/api-tutorial3
22:05:30  <defunctzombie>it is not a silver bullet
22:05:37  <mbalho>you have to write code a certain way
22:05:43  <mbalho>and its marginal (in my experience)
22:06:05  <mbalho>and you have to bundle the closure compiler build chain with your project which makes the repo size way bigger than it needs to be :P
22:06:17  <defunctzombie>mbalho: not true
22:06:24  <defunctzombie>they have an api endpoint service :)
22:06:26  <CoverSlide>no, you can have the jar external
22:06:45  <mbalho>defunctzombie: oooh did not know
22:06:48  <CoverSlide>well i guesss still if you want it you need to have it
22:06:53  <defunctzombie>https://github.com/shtylman/reunion#makefile-magic
22:06:57  <defunctzombie>mbalho: ^
22:07:02  <CoverSlide>but we never kept the jar in our repos i guess is what i'm saying
22:07:07  <mbalho>ah
22:07:46  <defunctzombie>it is a really easy way to minify your stuff without having to have other stuff installed
22:07:52  <defunctzombie>just curl
22:07:53  <defunctzombie>heh
22:07:56  <exit2>when I move to SF can we all party and talk about writing punters for AOL?
22:08:08  <CoverSlide>d
22:08:08  <CoverSlide>14:07 < defunctzombie> just curl
22:08:13  <mbalho>exit2: what is a punter?
22:08:24  <defunctzombie>haha
22:08:40  <exit2>mbalho: you never wrote 3rd party applications for AOL back in the 90s and early 2000's?
22:08:46  <mbalho>haha nope
22:08:47  <Raynos>mikolalysenko: script tags and global namespaces
22:08:53  <Raynos>mikolalysenko: ES6 modules
22:09:05  <defunctzombie>Raynos: ew
22:09:07  <exit2>mbalho: bummer, I'm always searching for people who started programming by creating 'PrOgZ' for AOL
22:09:16  <mbalho>lol
22:09:19  <exit2>mbalho: things like this http://en.wikipedia.org/wiki/AOHell
22:09:21  <Raynos>well global namespaces aren't that bad
22:09:30  <Raynos>require(module) vs window[module] its the same thing
22:09:37  <Raynos>except require enforces zero conflicts
22:10:00  <mikolalysenko>Raynos: well that, and the fact that you have tools like a common package manager
22:10:09  <mikolalysenko>which can manage dependencies and so on
22:10:11  <exit2>90's AOL hacking is where it's at
22:10:25  <mbalho>exit2: thats awesome haha
22:11:07  <exit2>I watched and interview with Kevin Systrom and he said his early days started hacking on AOL and Compuserve heh
22:11:08  <Raynos>mikolalysenko: loading and package managers are two seperate things
22:11:18  <Raynos>the package manager thign is solved. it's called npm
22:11:40  <mikolalysenko>that's true, I was simply pointing out that globals kind of preclude that possibility
22:11:51  <mbalho>npm is good enough but the programmer facing API could always get better (browserify etc)
22:12:20  <mikolalysenko>browserify is already good enough, in my opinion
22:12:43  <defunctzombie>mbalho: agreed
22:12:59  <mbalho>defunctzombie: whatever happened to getting JSON output from browserify?
22:13:00  <mikolalysenko>one thing that is a bit awkward though are webworkers...
22:13:36  <CoverSlide>webworkers?
22:13:41  <defunctzombie>mbalho: dunno, other stuff came up for substack, I use my own tool so wasn't a priority for me :/
22:13:49  <mbalho>defunctzombie: gotcha
22:13:58  <defunctzombie>I think it has less appeal than originally thought?
22:14:03  <mikolalysenko>yeah, it would be nice to write parallel code for some stuff
22:14:14  <mbalho>mikolalysenko: i hacked up this a while back https://npmjs.org/package/workerstream
22:14:30  <mbalho>mikolalysenko: doesnt take advantage of the new shared arrays in chrome though
22:14:41  <CoverSlide>could probably monkey up something with thie child_process.fork api
22:14:41  <mbalho>(yet)
22:14:55  <mikolalysenko>hmm
22:15:08  <mbalho>mikolalysenko: but that doesnt provide anything like what the node cluster module does
22:15:16  <mbalho>mikolalysenko: though that could be polyfilled probably
22:15:28  <mbalho>mikolalysenko: i like to think about which things from node can be polyfilled in browsers :D
22:15:31  <mikolalysenko>mbalho: That's true, but cluster solves a different (and harder) problem
22:15:56  * exit2quit (Remote host closed the connection)
22:15:56  <mikolalysenko>what I would like is some way to get parallel execution in a script that works transparently in both node and on the browser
22:16:10  <Raynos>http://www.webbrowsercompatibility.com/dom/desktop/ <_
22:16:13  <mbalho>mikolalysenko: ahh good point. an API like require('async').parallel that used web workers would be cool
22:16:14  <Raynos>That is heaven send
22:16:15  <Raynos>HEAVEN SEND
22:16:57  <Raynos>miko, defunctzombie: browserify is not good enough for people unknown to node
22:16:58  <mikolalysenko>maybe something like require_spawn("script.js") ?
22:17:09  <mikolalysenko>or just spawn("script.js")
22:17:27  <Raynos>if people want to use my module they should be able to do `<script src="require"><script src="my-module">`
22:17:41  <Raynos>we just a dirty hacked version of browserify that works as script src :D
22:18:05  <Raynos>something like a global module object with a setter for exports :p
22:18:12  <mikolalysenko>that's not a bad approach
22:18:16  <Raynos>that checks what script tag is currently executing
22:18:33  <Raynos>and makes require("my-module") return that value
22:18:39  <mikolalysenko>hmm
22:18:51  <mbalho>Raynos: i +1 that bigtime
22:19:02  <Raynos>it wont work in IE8 though
22:19:05  <Raynos>but tahts ok fuck IE8
22:19:18  <mbalho>Raynos: mostly because 99.9% of client side devs expect to include script tags when they put new projects in
22:19:27  <Raynos>we can build a quick and dirty hack version of this
22:19:44  <mbalho>Raynos: right now every user of every module has to have browserify installed but if it could just be every author of every module it would spread faster (methinks)
22:20:25  <mikolalysenko>mbalho: Maybe, though I also think that again this might be easier to solve with the right tooling
22:20:56  <mikolalysenko>I know Raynos has seen this, but have you looked at this short little hack I wrote the other day?
22:20:59  <mikolalysenko>https://github.com/mikolalysenko/Serverify
22:21:21  <Raynos>mbalho: thats a seperate approach
22:21:48  <mbalho>mikolalysenko: i have not tried it yet, will do soon
22:21:50  <Raynos>having a one line tool that you can add to scripts: { prepublish: "globalify --name=jQuery index.js" }
22:23:12  <mikolalysenko>hmm... I am still not sure though what the best way to handle web workers in node.js would be though
22:23:42  <mikolalysenko>I guess you could just list all the worker processes you need outside the code, then run browserify on them to get something that works on the client
22:24:03  <mikolalysenko>but the downside is that you would need multiple files...
22:24:34  * fotoveritejoined
22:24:56  <mikolalysenko>though I think you might be able to do something by perhaps modifying the bootstrap code/entry for node.js to check which module is getting loaded
22:25:15  <mikolalysenko>so if you are in a worker, you could maybe wait until you get a message and then dispatch the appropriate script
22:26:08  * fotoverite_joined
22:26:12  * fotoveritequit (Read error: Connection reset by peer)
22:26:35  * fotoverite_changed nick to fotoverite
22:27:24  <mbalho>mikolalysenko: im gonna need to tackle this problem soon to do chunk generation/serializing/deserializing, though node is less of a priority to me
22:27:55  <mikolalysenko>mbalho: yeah, I've dealt with it myself
22:28:01  <mbalho>mikolalysenko: i got all the physics from voxel-engine running in node https://github.com/maxogden/voxel-server/blob/master/server.js
22:28:08  <defunctzombie>Raynos: you could have a client require, it is not that hard
22:28:28  <defunctzombie>I guess I just don't see the win as much since I already have tooling in my stack to do it all automatically
22:28:34  * fotoveritequit (Client Quit)
22:28:34  <mikolalysenko>if you want to see a (bad) not commonjs solution here is an old version I wrote in dumb javascript: https://github.com/mikolalysenko/NodeMinecraftThing
22:28:35  <mbalho>mikolalysenko: but i think instead of paralellism i am just gonna load balance to scale up servers (or just cap servers at like 20 players)
22:28:38  <defunctzombie>but for people on other frameworks, yes
22:28:50  <mbalho>mikolalysenko: i got that running a couple of weeks ago actually hehe
22:28:54  <defunctzombie>that is why you can ship prebuilt stuff for them
22:28:58  <mikolalysenko>mbalho: ah cool
22:29:07  <defunctzombie>but really, they too could have nice tooling to do it with their stack
22:29:24  <defunctzombie>if my web stack is not doing the web things I need, then it is kind of a pointless web stack :/
22:29:40  <mikolalysenko>mbalho: One thing I found when working on that was that the main bottleneck in web workers was communication complexity
22:29:51  <mikolalysenko>mbalho: (Though this may have changed now with typed array sharing)
22:30:03  <mikolalysenko>mbalho: Most of the overhead came from stringifying/parsing objects
22:30:18  <defunctzombie>Raynos: I think tools like browserify are good enough actually, it is just one command to make your built js file if that is what you want
22:30:24  <mbalho>mikolalysenko: yea exactly, but the 'transferable objects' fixes that mostly
22:30:30  <mbalho>mikolalysenko: though i dont think it exists in node
22:30:39  <Raynos>BLARGH
22:30:40  <mbalho>mikolalysenko: i know its in chrome, dunno about other browsers
22:31:00  <mikolalysenko>mbalho: Well, I wouldn't worry about node since you probably won't need to transfer big blobs around in it
22:31:08  <mbalho>mikolalysenko: good point
22:31:11  <mikolalysenko>mbalho: The slow part I found was just the mesh generation
22:31:28  <mikolalysenko>mbalho: If you can do that in a worker, you should be able to get decent performance
22:31:44  <mbalho>mikolalysenko: rolnaaba is gonna start hacking on storing the chunk data in indexeddb
22:32:08  <mbalho>mikolalysenko: and bulk writes might introduce some slowdown, though leveldb has smart bulk buffering
22:32:27  <mikolalysenko>mbalho: have you thought about alternative chunk storage strategies?
22:32:35  <mbalho>mikolalysenko: not really :P
22:32:44  <mbalho>mikolalysenko: im intrigued by your RLE stuff
22:32:47  <mikolalysenko>mbalho: One thing that I did in that demo that worked pretty well was that I run length encoded all the voxels in memory
22:33:06  <mikolalysenko>mbalho: Which saves a lot of bandwidth when transfering chunks and also speeds up stuff like meshing
22:33:33  <mikolalysenko>mbalho: The downside though was that because I used a sorted array instead of a binary tree, random updates were super slow
22:33:44  <mbalho>ah
22:34:02  <mikolalysenko>mbalho: but since that rarely ever happens, it turns out that it doesn't matter
22:34:33  <mikolalysenko>mbalho: However, another interesting alternative which I've been thinking about is using packed memory arrays to maintain the runs instead
22:34:37  <mbalho>mikolalysenko: wouldnt a player editing a single voxel be a random update?
22:34:54  <mikolalysenko>mbalho: Yep, but compared to other operations it isn't that frequent
22:35:04  <mbalho>ahh
22:35:07  <mikolalysenko>mbalho: and if you update a chunk, you still have to remesh it which is O(n) anyway
22:35:20  <defunctzombie>Raynos: hell yea
22:35:33  <mikolalysenko>mbalho: so what I would do is just buffer all the edits and then merge them in one shot by marching over the runs
22:36:19  <mikolalysenko>mbalho: Here is the relevant code I wrote: https://github.com/mikolalysenko/NodeMinecraftThing/blob/master/client/voxels.js
22:36:36  <mikolalysenko>mbalho: but it is pretty ugly since I was still learning javascript when I wrote it
22:36:53  <mbalho>mikolalysenko: looks like most JS algorithm code :P
22:37:43  <mikolalysenko>mbalho: I am currently working on a new library that handles smooth surfaces using rle encoded data and it is much cleaner
22:37:57  <mikolalysenko>https://github.com/mikolalysenko/rle-core
22:38:26  <mbalho>mikolalysenko: would you say rle-core makes the voxels.js stuff irrelevant?
22:38:31  <mikolalysenko>mbalho: no
22:38:42  <mikolalysenko>mbalho: it does curved/smooth stuff, not minecraft blocky meshes
22:38:44  <mbalho>ah
22:38:51  <mikolalysenko>mbalho: also it is for CAD applications
22:39:13  <mikolalysenko>mbalho: I am planning on writing a post on using it in conjunction with this project I made to do 3d printing stuff in javascript
22:39:19  <mbalho>mikolalysenko: oh man that is awesome
22:39:27  <mikolalysenko>https://github.com/mikolalysenko/ShapeWaysJS
22:39:29  <mbalho>mikolalysenko: i know at least 3 people who have asked me if voxel.js is suitable for printing
22:39:37  <mbalho>mikolalysenko: and i showed them your smooth isosurfaces post
22:39:49  * AvianFluquit (Remote host closed the connection)
22:39:49  <mikolalysenko>mbalho: well, you should also show them shapewaysjs
22:40:06  <mbalho>mikolalysenko: i live in oakland and theres a new hackerspace downtown with a 3d printer. i recently learned how to use it
22:40:06  <mikolalysenko>in fact you could probably even use that with voxeljs to get 3d printed stuff right now
22:40:21  <mikolalysenko>mbalho: cool! I am actually heading out to oakland next month
22:40:37  <mbalho>mikolalysenko: hey awesome you should come hang out with me and substack, we can 3d print some stuff
22:40:49  <mikolalysenko>I work part time for 3d systems now (while still working on my phd), doing 3d printing stuff
22:40:53  <niftylettuce>isaacs: hmph keep getting npm errors, and npm init is all funky too erroring out with defaults
22:40:59  <Raynos>miko, mbalho, defunctzombie: https://github.com/codylindley/frontend-tools
22:41:06  <mikolalysenko>mbalho: alright sounds like a plan!
22:41:09  <Raynos>That's pretty much the entire other stack we're up against
22:41:12  <Raynos>it's the "anti-npm" stack
22:41:17  <Raynos>It is a stack made of sads
22:41:21  <mbalho>mikolalysenko: didnt chris anderson from diy drones just start working out of their offices?
22:41:47  <mikolalysenko>mbalho: maybe, last time I was down there was in late november
22:41:50  <mbalho>ahh
22:42:18  <mbalho>mikolalysenko: a demo that is one the todo list for me soon is a voxelification library for importing .stl files in as voexls
22:42:49  <mbalho>mikolalysenko: where you set your scale factor and then it just rasterizes the stl, should be pretty easy to do
22:42:55  <mikolalysenko>mbalho: That would be cool. I've thought about writing a raster converter as well
22:43:07  <niftylettuce>isaacs: u don't prevent "node" or "js" in npm package names, do you?
22:43:41  <mikolalysenko>mbalho: You can do a pretty good job by just checking for box-triangle intersections, though it is a bit slow
22:43:44  <mbalho>mikolalysenko: i did a fellowship at Code for America in 2011 and some of the new fellows this year met up with me this week to talk about getting open data into voxel.js to make minecraft style interfaces to things like bus schedules and city planning/pothole reporting apps
22:44:20  <mbalho>mikolalysenko: one guy (@rclosner) is working this week on getting open street map data rasterized into voxels
22:44:42  <mbalho>mikolalysenko: ill look up box-triangle intersections, thanks
22:45:13  <mbalho>mikolalysenko: ahha in the first few google results http://www.minecraftforum.net/topic/55508-another-obj-importer/
22:45:14  <mikolalysenko>mbalho: That would be pretty neat, if they get something up and running it would be interesting to see it
22:45:17  <defunctzombie>Raynos: "stack made of sads" wow
22:45:48  <mikolalysenko>mbalho: Though before you write the stl/ply importer I got a suggestion
22:45:58  <mikolalysenko>mbalho: why not just write a generic stl importer first?
22:46:00  <niftylettuce>mbalho: how is voxels
22:46:07  <mikolalysenko>mbalho: and then write a rasterizer independent of it
22:46:09  <mbalho>mikolalysenko: there is one already actually in three.js
22:46:23  <CoverSlide>holy shit
22:46:25  <mikolalysenko>mbalho: yeah, but it spits out three.js style meshes which are pretty heavy
22:46:30  <mbalho>ahhh
22:46:33  <CoverSlide>so the earth will be voxellized!!!
22:46:51  <mikolalysenko>mbalho: I think stripping it down to something with just an array vertices/faces might be a bit easier to work with long term
22:46:56  <mbalho>mikolalysenko: good call
22:47:05  <niftylettuce>CoverSlide: haha they dont stopp till every planet is voxellized
22:47:17  * nk109joined
22:47:18  <niftylettuce>CoverSlide: next u know it they are snagging [email protected]@ data
22:47:41  <niftylettuce>isaacs: figured my issue, it was git head reference, bah :D
22:47:44  <mikolalysenko>mbalho: (though as a disclaimer I am generally skeptical of custom math classes in javascript, for both performance and convenience reasons)
22:48:19  <mbalho>mikolalysenko: npm install stl doesnt exist yet muahaha
22:48:30  <mikolalysenko>mbalho: Go for it
22:49:02  <CoverSlide>what about .obj?
22:49:11  <mikolalysenko>mbalho: and while you are at it, make a ply, obj and wrl
22:49:23  <mbalho>mikolalysenko: ahaha
22:49:44  <mikolalysenko>mbalho: also, you may want to look at this
22:49:45  <mikolalysenko>https://github.com/mikolalysenko/TrimeshJS
22:50:04  <mikolalysenko>I am currently working on splitting it up, but I think that some of the ideas are still sound
22:50:21  <mikolalysenko>in particular avoiding custom mesh data structures is a really good idea in javascript
22:50:45  <mikolalysenko>since you can avoid stuff like having to create fancy custom vertex classes and so on
22:51:21  <mikolalysenko>ie instead of doing something like new Vertex(x, y, z, nx, ny, nz, r, g, b, ...)
22:51:39  <mikolalysenko>just return some arrays, like positions[], normals[], colors[], etc
22:51:42  <mikolalysenko>and a list of face indices
22:51:57  <mbalho>mikolalysenko: sounds nice and simple
22:52:03  <mikolalysenko>yeah
22:52:20  <mikolalysenko>that's all you really need to draw it or run some algorithm
22:52:36  <mikolalysenko>if you need stuff like topological data (say edge or vertex incidences) then you just recompute it
22:52:44  <mikolalysenko>or cache it and reuse it if necessary
22:53:00  <mikolalysenko>and in fact I now have an npm package for doing just that: https://github.com/mikolalysenko/mesh-topology
22:53:06  <mbalho>lol
22:53:35  <mikolalysenko>so no confusing winged edge or render dynamic or whatever mesh data structure flavor of the month bullshit
22:53:43  <mikolalysenko>if you need a query, just build an index and do it
22:53:46  <mbalho>haha geometry hipsters
22:53:54  <mbalho>i didnt know that was a thing
22:54:39  <mikolalysenko>(welcome to life in grad school)
22:54:48  <mbalho>heh
22:54:51  <mikolalysenko>but anyway, I think that this approach is quite workable and flexible
22:55:20  <mikolalysenko>and it also avoids introducing dependencies on heavy weight libraries like THREE.js
22:56:56  <mbalho>mikolalysenko: i like three but only because im a 3d noob
22:57:09  <mbalho>mikolalysenko: though it is definitely heavy
22:57:12  <mikolalysenko>mbalho: I have a bit of a love/hate relationship with it
22:57:29  <mikolalysenko>mbalho: On the one hand, it does make doing simple stuff really simple
22:57:36  <mbalho>cafe closing, gotta run
22:57:47  <mikolalysenko>ok, bye
23:02:31  <Raynos>https://github.com/wilmoore/frontend-packagers/issues/5
23:02:37  <Raynos>he dares not mention npm
23:02:43  <Raynos>we should break his knee caps
23:30:12  * mikolalysenkoquit (Ping timeout: 264 seconds)
23:30:56  <defunctzombie>hahaha
23:31:01  <defunctzombie>I like tj's comment
23:41:54  * mikolalysenkojoined
23:47:07  <mbalho>shama: LOL
23:47:16  <shama>:)
23:47:34  <mbalho>shama: its just like real life now
23:47:54  <mbalho>shama: paul campbell in ireland said he got his drone stuck in a tree and left it there for 3 weeks because he was lazy
23:48:03  <shama>hahah
23:48:59  * exit2joined
23:49:16  <shama>the second time I flew my drone a tree put it out of commission for a month
23:50:53  <mbalho>ol
23:50:55  <mbalho>+l
23:51:54  * tilgoviquit (Remote host closed the connection)
23:52:29  <mbalho>mikolalysenko: this seems fairly minimal https://github.com/pjoe/three.js/commit/5faf0944735f96119874002842d0e79fb5de99f1
23:53:36  <Raynos>chrisdickinson, defunctzombie: https://gist.github.com/4552149
23:54:31  <defunctzombie>write it using normal looking js
23:59:30  <defunctzombie>Raynos: to do a basic mouse enter/leave you now have all this additional baggage, seem unnecessary and makes it both harder to follow/understand and update
23:59:50  <defunctzombie>I need to learn what all these extra things do just to look at what should be a tiny code snippet