00:00:01  * ircretaryquit (Remote host closed the connection)
00:00:10  * ircretaryjoined
00:04:58  * yoshuawuytsquit (Ping timeout: 264 seconds)
00:28:13  * thlorenzjoined
00:44:54  <mafintosh>mikolalysenko: assuming i have two sorted lists. the first N elements of these lists are equal (N can be 0). whats the best algorithm for finding N?
00:45:23  <mikolalysenko>mafintosh: binary search
00:46:11  <mikolalysenko>though maybe I am misunderstanding here
00:46:26  <mikolalysenko>is it that all of the first n elements are equal to the same thing?
00:46:33  <mafintosh>mikolalysenko: yes
00:46:38  <mikolalysenko>or that they are two sorted lists and you want to find the longest common prefix?
00:46:54  <mikolalysenko>in the first case I am thinking it is like you have xxxxxxxy and xxxxz
00:47:01  <mikolalysenko>and you want to count how many x's you have
00:47:20  <mikolalysenko>while in the other one it would be you have: abcdpq and abcdxyz
00:47:27  <mikolalysenko>and you want to find the abcd
00:47:35  <mafintosh>mikolalysenko: i want to find abcd
00:47:41  <mafintosh>mikolalysenko: or actually just d
00:47:41  <mikolalysenko>ok, so it is the prefix problem
00:48:16  <mikolalysenko>so if they were stored in suffix arrays this would be easy
00:48:21  <domanic>if you just start binary searching from min(a.length, b.length)
00:49:10  <mikolalysenko>mafintosh: I think best you can do then is linear scan
00:49:11  <substack>mafintosh: you could start at 1 and increase by powers of 2 until you get a miss
00:49:14  <mikolalysenko>by an adversary argument
00:49:29  <mikolalysenko>since suppose the two strings are = execpt for 1 character
00:49:34  <substack>then binary search between the miss and the last match
00:50:05  <mikolalysenko>pick any algorithm which reads less than every character
00:50:09  <substack>ah right, forgot about that
00:50:15  <mikolalysenko>whatever character you haven't read make that the different character
00:50:25  <mikolalysenko>so until you process each character you can't know
00:50:28  <mikolalysenko>sorry :(
00:50:36  <mikolalysenko>but if it was that first problem then you could binary search
00:50:44  <mikolalysenko>OR if you can preprocess it you can do way better
00:51:17  <mafintosh>mikolalysenko: i can preprocess assuming the space complexify is linear
00:51:23  <mikolalysenko>OK!
00:51:26  <mikolalysenko>we are in business again then
00:51:30  <mikolalysenko>you can use suffix arrays
00:51:35  <mikolalysenko>http://en.wikipedia.org/wiki/LCP_array
00:52:33  <mikolalysenko>http://en.wikipedia.org/wiki/Suffix_array
00:52:35  <mikolalysenko>or that
00:52:37  <mikolalysenko>either works
00:52:51  <mafintosh>mikolalysenko: all the elements in my list are also sorted
00:52:59  <mikolalysenko>hmm
00:53:08  <mikolalysenko>that might make it a lot simpler
00:53:37  <mafintosh>mikolalysenko: what if i used substacks approach but started from the end of the list instead of from the beginning?
00:54:03  <mikolalysenko>it might not detect a miss though
00:54:18  <mikolalysenko>aaaabzzzz
00:54:20  <mikolalysenko>vs
00:54:25  <mikolalysenko>aaaaczzzz
00:54:44  <mikolalysenko>if you don't check the c you might miss it all
00:55:05  <mafintosh>mikolalysenko: if i don't have duplicates does it work then?
00:55:12  <mikolalysenko>no
00:55:25  <mikolalysenko>replace aaaa/zzzz with abcd and wxyz
00:55:33  <mikolalysenko>but I got a solution with O(n) space
00:55:40  <mafintosh>mikolalysenko: interesting :)
00:55:42  * phatedquit (Remote host closed the connection)
00:55:43  <mikolalysenko>it involves precomputation though
00:55:58  <mikolalysenko>compute a prefix sum of all previous strings
00:56:01  <mikolalysenko>via a running checksum/hash
00:56:15  <mikolalysenko>and store that in a table
00:56:29  <mikolalysenko>and use that to test equality of prefixes
00:57:00  <mikolalysenko>you can get the largest prefix in O(log n) time by binary searching on that to find the first element where the two arrays differ
00:57:45  <mikolalysenko>that is you have an array, call it prefixHash where prefixHash[i] = hash(array[0...i])
00:57:56  <mikolalysenko>and you just binary search on that to find first point where they differ
01:00:04  <mafintosh>mikolalysenko: i binary search on the hash values?
01:00:21  <mikolalysenko>you binary search until you find the first pair which are not equal
01:00:43  <mikolalysenko>that is the predicate (prefixHashA[i] === prefixHashB[i])
01:00:47  <mikolalysenko>which is monotone
01:01:11  <mikolalysenko>I bet there is a way to do this a bit faster though and maybe save some space
01:01:22  <mikolalysenko>but log(n) is probably good enough in practice
01:02:12  <mikolalysenko>you could save a log factor of space by indirection
01:02:23  <mikolalysenko>by storing only every log(n) hash
01:02:33  <mikolalysenko>and then for the last log(n) just brute force scan it
01:02:47  <mikolalysenko>so search is still O(log(n)) but storage is O(n/log(n))
01:02:55  <domanic>mafintosh, guessing this is for a replication algorithm
01:03:02  <domanic>right?
01:03:13  <mafintosh>domanic: yea
01:04:08  <mikolalysenko>gut feeling is there is a way to speed up the log(n) factor here using some fast selection algorithm, but those get tricky
01:04:36  <domanic>mafintosh, so this list is some sort of hash dag
01:05:22  <mafintosh>domanic: its a path in a hash dag
01:05:40  <domanic>so I'm guessing there is a cryptographically secure partial order + a total order based on timestamps or somethnig
01:06:01  <mikolalysenko>mafintosh: are you trying to compute least common ancestor of two nodes?
01:06:07  <mikolalysenko>in these dags
01:06:20  <mafintosh>mikolalysenko: yes - distributed
01:06:27  <mikolalysenko>ok
01:06:45  <mikolalysenko>can you precompute some data for these dags?
01:06:53  <mafintosh>mikolalysenko: yes
01:06:59  <mikolalysenko>if you are allowed to preprocess them you can do it in O(1) for O(n/log(n)) space
01:07:19  <mikolalysenko>the trick is to reduce the lca query to a range minimum query
01:08:04  <mikolalysenko>actually a question:
01:08:19  <mikolalysenko>is there just one big dag, or are there multiple dags?
01:08:39  <mafintosh>mikolalysenko: currently its one big dag
01:08:43  <mikolalysenko>ok
01:08:52  <mikolalysenko>and you can walk the whole dag and preprocess it
01:09:13  <mikolalysenko>and there is a root in the dag
01:09:27  <mikolalysenko>is it a dag or a tree?
01:09:48  <mafintosh>mikolalysenko: there is a root. its a dag. i can preprocess when i insert a new node
01:10:04  <mikolalysenko>is O(n) preprocessing ok?
01:10:51  <mafintosh>mikolalysenko: lets assume it is
01:10:57  <mikolalysenko>ok
01:11:24  <mikolalysenko>now for the query: are we given a path as input or an item in the dag?
01:11:41  <mafintosh>mikolalysenko: item
01:11:49  <mikolalysenko>hmm
01:12:04  <mafintosh>mikolalysenko: oh i misunderstood you
01:12:07  <mafintosh>mikolalysenko: a path
01:12:13  <mikolalysenko>ok
01:13:03  <domanic>mafintosh, how is the dag sorted?
01:13:19  <domanic>how do you know the prefix is shared (to some N?)
01:13:34  <mikolalysenko>so there is this module I wrote a while ago: https://github.com/mikolalysenko/least-common-ancestor/blob/master/lca.js
01:13:39  <mikolalysenko>but it is for trees, not dags
01:13:46  <domanic>is it possible to insert something to the prefix? or is that just unlikely?
01:13:52  <mafintosh>domanic: you create paths from the root to the heads until you've covered the entire dag
01:13:52  <mikolalysenko>you could also speed it up a bit using 1 layer of indirection
01:14:14  <mafintosh>domanic: each of these paths are ordered based on height in the graph
01:14:36  <domanic>mafintosh, how do you break the tie between two parallel paths?
01:15:01  <domanic>(so, basically I walk the graph links in reverse?)
01:15:29  <mafintosh>domanic: something like that (not fully baked yet)
01:15:52  <mafintosh>domanic: the two peers don't need to have the same paths
01:16:25  <mafintosh>domanic: so lets say i have a path (a, b, c, d) where a etc are all nodes in the dag
01:16:35  <domanic>mafintosh, do you remember the binomial idea we discussed back in copenhagen?
01:16:50  <mafintosh>domanic: its related to that :)
01:16:57  <mikolalysenko>mafintosh: maybe this is what you want? https://algo2.iti.kit.edu/download/fischer10new.pdf
01:17:08  <domanic>cool, yes just with a different ordering mechanism
01:17:26  <mafintosh>mikolalysenko: thanks - looks very much like what i'm looking for
01:18:05  <mafintosh>domanic: so if you have a path (a, b, c, d) and a < b < c < d based on the height ordering and they are all nodes
01:18:15  <mikolalysenko>it gives a o(n) succinct structure for O(1) LSCA queries on dags
01:18:54  <mikolalysenko>err it is just O(n)
01:18:56  <mikolalysenko>but still not bad
01:19:15  <mafintosh>domanic: i send you a binomial digest, (d, b) in this case and you tell me if you have d or b
01:19:27  <domanic>mafintosh, idea: every object has a sequence number max(links->sequence number) + 1
01:20:09  <mafintosh>domanic: my height algorithm is max(links->height) + 1
01:20:32  <mafintosh>domanic: so my height is your sequence number?
01:21:14  <domanic>yeah - are you writing the height into the document though (of course, you reject documents that have invalid heights)
01:21:35  <mafintosh>i'm writing it into the document
01:21:42  <domanic>okay yeah that is the same
01:22:58  <mafintosh>domanic: so the number of paths are gonna be the same as the "widest" fork
01:23:36  <mafintosh>and you do this for every fork
01:23:43  <mafintosh>path not fork
01:23:58  <domanic>relocating, food
01:24:31  * anvakajoined
01:26:00  <mafintosh>mikolalysenko: so i actually already have the prefix hashes stored so no extra space complexity there
01:26:20  <mafintosh>in regards to the first algorithm
01:26:27  <mikolalysenko>ok, that simplifies things a lot then
01:27:01  <mikolalysenko>also that lsca thing may or may not be what you want
01:27:18  <mikolalysenko>it is different than lca, which I think is kind of open for general dags
01:27:22  <mikolalysenko>for trees it is solved
01:27:26  <mafintosh>mikolalysenko: wouldn't galloping search from the end be better than binary search is there is a good change that the prefix is long?
01:27:47  <mikolalysenko>maybe
01:27:53  <mikolalysenko>asymptotically, would be no difference
01:28:02  <mikolalysenko>but you could use your judgement here, you know the data
01:28:42  * domanicquit (Read error: Connection reset by peer)
01:29:16  * anvakaquit (Ping timeout: 272 seconds)
01:29:44  <mafintosh>mikolalysenko: i'll run some experiments
01:29:54  <mikolalysenko>there are lots of options for binary search variants
01:29:55  <mikolalysenko>http://en.wikipedia.org/wiki/Fibonacci_search_technique
01:30:01  <mikolalysenko>that has some nice theoretical properties
01:30:11  * dguttmanquit (Quit: dguttman)
01:30:20  <mikolalysenko>but all of them get O(log(n)) at the end of the day
01:30:20  <mafintosh>mikolalysenko: since this is distributed its all about minimizing round trips
01:30:30  <mikolalysenko>ah, got it
01:30:50  <mikolalysenko>there might be a way to do this in O(1)
01:30:58  <mafintosh>whoa
01:31:10  <mikolalysenko>need to think about it more though
01:31:58  <mafintosh>mikolalysenko: do you mean solve the common prefix in O(1)?
01:32:07  <mikolalysenko>with preprocessing
01:33:25  <mikolalysenko>so here is another question: is this a situation where the client is communicating to some server?
01:33:42  * kesslerquit (Remote host closed the connection)
01:33:42  <mikolalysenko>and so you query the hash of the path at different locations
01:34:29  <mafintosh>mikolalysenko: yea
01:34:48  <mikolalysenko>so maybe you could send multiple hashes at once to speed up the search
01:35:00  <mikolalysenko>say maybe O(log(n)) even?
01:35:02  <mafintosh>mikolalysenko: the idea is i have a path of merkle dag nodes, (a, b, c, d, e, ...) a < b ... based on the "height" in the graph
01:35:43  <mafintosh>mikolalysenko: if you tell me you have c i know you have a b as well
01:36:47  <mafintosh>mikolalysenko: so in as few roundtrips as possible i need to know which nodes we share in the dag
01:36:52  <mafintosh>*path
01:36:58  <mikolalysenko>ok
01:37:20  <mafintosh>sending multiple hashes is a good idea
01:37:22  <mikolalysenko>and is it reasonable to send up to say log(n) hashes in one round trip?
01:37:35  <mafintosh>mikolalysenko: yea i think so
01:37:40  <mikolalysenko>obviously sending o(n) would work, but it is cheating
01:39:15  <mafintosh>mikolalysenko: my initial idea was to send the last node, the last node - 2, the last node - 4 ... -8 etc in one round trip
01:39:44  <mikolalysenko>seems reasonable, but you might still need more rounds to locate prefix
01:40:24  <mafintosh>mikolalysenko: thats why i asked you :) i'm wondering if you could optimize this
01:40:32  <mafintosh>what i have might already be good enough
01:41:18  <mafintosh>mikolalysenko: i guess a simple distributed binary search would work as well with log(n) round trips
01:41:46  <mikolalysenko>yeah, though biasing toward the end might be better in practice given the distribution of data
01:42:02  <mikolalysenko>trying to think if there is a way to beat the O(log(n)) bound...
01:44:11  <mafintosh>mikolalysenko: re biasing at the end, thats why i was thinking of galloping search
01:44:49  <guybrush>wooah for a moment i thought this is the end of the world.. https://dl.dropboxusercontent.com/u/8314617/storm.jpg
01:44:53  <mikolalysenko>yeah, it makes sense
01:49:04  * yoshuawuytsjoined
01:50:07  <mikolalysenko>I think I have an idea that might work
01:50:23  <mikolalysenko>it is a bit complicated to explain, but I believe you can do it in 1 rtt
01:50:30  <mikolalysenko>with O(log(n)) messages
01:50:38  <mikolalysenko>err a message of length O(log(n))
01:51:06  <mikolalysenko>it might be easier to do an implementation than explain it though
01:51:17  <mikolalysenko>but the idea is to use a butterfly technique
01:51:38  <mikolalysenko>http://en.wikipedia.org/wiki/Butterfly_diagram
01:51:58  <mikolalysenko>what you do is you transmit the following numbers:
01:52:03  <mikolalysenko>1. the xor of all hashes
01:52:08  <mikolalysenko>2. the xor of every other hash
01:52:13  <mikolalysenko>3. the xor of every 4th hash
01:52:16  <mikolalysenko>etc.
01:52:33  <mikolalysenko>n. the xor of every 2^{n-1} hash
01:52:39  <mikolalysenko>ok
01:52:51  <mikolalysenko>so you get that data on the server and you want to find where it differs in your path
01:53:00  <mikolalysenko>so you compute those sums for your path too
01:53:14  <mikolalysenko>err
01:53:15  <mikolalysenko>hmm
01:53:18  <mikolalysenko>this won't work never mind
01:53:23  * yoshuawuytsquit (Ping timeout: 244 seconds)
01:54:44  <mikolalysenko>might be salvageable, gonna work this out on paper too hard to explain on irc
01:58:17  <mafintosh>mikolalysenko: keep me in the loop :) i'm excited about this
02:08:32  * thlorenzquit (Remote host closed the connection)
02:15:32  * jxson_joined
02:16:44  * domanicjoined
02:19:22  * jxsonquit (Ping timeout: 256 seconds)
02:19:56  * jxson_quit (Ping timeout: 256 seconds)
02:55:37  * reqsharkquit (Quit: Be back later ...)
03:09:11  * thlorenzjoined
03:09:33  * jxsonjoined
03:12:47  * anvakajoined
03:13:55  * thlorenzquit (Ping timeout: 256 seconds)
03:16:57  * anvakaquit (Ping timeout: 240 seconds)
03:22:34  * kesslerjoined
03:27:42  * kesslerquit (Ping timeout: 272 seconds)
03:29:50  * jxsonquit (Remote host closed the connection)
03:32:40  * anvakajoined
03:42:15  * reqsharkjoined
04:10:11  * thlorenzjoined
04:11:19  * pfrazequit (Remote host closed the connection)
04:15:48  * thlorenzquit (Ping timeout: 276 seconds)
04:16:52  * anvakaquit (Remote host closed the connection)
04:17:26  * anvakajoined
04:21:46  * anvakaquit (Ping timeout: 256 seconds)
04:23:17  * kesslerjoined
04:25:56  * tilgoviquit (Ping timeout: 240 seconds)
04:27:02  * dguttmanjoined
04:27:43  * anvakajoined
04:27:44  * kesslerquit (Ping timeout: 246 seconds)
04:29:17  * tilgovijoined
04:49:15  * dguttmanquit (Quit: dguttman)
04:55:33  * anvakaquit (Remote host closed the connection)
04:56:08  * anvakajoined
04:58:34  * fotoveritequit (Quit: fotoverite)
04:59:15  * anvaka_joined
05:00:39  * anvakaquit (Ping timeout: 245 seconds)
05:09:30  * jxsonjoined
05:11:16  * thlorenzjoined
05:13:08  * knownasilyaquit (Quit: Connection closed for inactivity)
05:15:36  * thlorenzquit (Ping timeout: 240 seconds)
05:31:42  * yoshuawuytsjoined
05:35:00  * kanzurequit (Read error: No route to host)
05:39:02  * kesslerjoined
05:43:52  * kesslerquit (Ping timeout: 272 seconds)
05:49:36  * harrowquit (Ping timeout: 256 seconds)
06:01:03  * harrowjoined
06:08:37  * domanicquit (Ping timeout: 244 seconds)
06:15:55  <tixz>I have a local barebones http server running and try to ping it with `curl -X OPTIONS http://localhost:8080` but am just left with "Empty reply from server". I'm OS X and all other HTTP methods seem to work fine. Has anyone experienced this before?
06:25:49  * tilgoviquit (Remote host closed the connection)
06:29:04  * kanzurejoined
06:30:35  * yoshuawuytsquit (Ping timeout: 246 seconds)
06:54:51  * kesslerjoined
06:57:47  * yoshuawuytsjoined
06:59:18  * kesslerquit (Ping timeout: 256 seconds)
07:38:58  * machtyquit (Ping timeout: 256 seconds)
07:40:46  * jxsonquit (Remote host closed the connection)
07:43:05  * machtyjoined
08:14:48  * yoshuawuytsquit (Quit: WeeChat 1.1.1)
08:14:58  * yoshuawuytsjoined
08:18:01  * erikgjoined
08:18:38  * insertcoffeequit (Ping timeout: 256 seconds)
08:20:18  * insertcoffeejoined
08:26:29  * farnsworthquit (Ping timeout: 245 seconds)
08:27:41  * farnsworthjoined
08:30:39  * kesslerjoined
08:41:41  * rannmannquit (Ping timeout: 265 seconds)
08:45:47  * rannmannjoined
08:58:04  * kanzurequit (*.net *.split)
08:58:05  * ircretaryquit (*.net *.split)
08:58:05  * sz0quit (*.net *.split)
08:58:05  * mk30quit (*.net *.split)
08:58:05  * marcello4dquit (*.net *.split)
08:58:06  * cubertquit (*.net *.split)
09:00:19  * kanzurejoined
09:00:19  * ircretaryjoined
09:00:19  * sz0joined
09:00:19  * mk30joined
09:00:19  * marcello4djoined
09:00:19  * cubertjoined
09:10:51  * kesslerquit (Remote host closed the connection)
09:40:20  * kesslerjoined
09:51:30  * kesslerquit (Remote host closed the connection)
10:08:50  * kesslerjoined
10:09:16  * kesslerquit (Read error: Connection reset by peer)
10:09:46  * kesslerjoined
10:10:41  * kesslerquit (Remote host closed the connection)
10:43:31  * domanicjoined
10:58:13  * kesslerjoined
11:01:31  * domanicquit (Ping timeout: 250 seconds)
11:20:08  * kesslerquit (Remote host closed the connection)
11:30:26  * kesslerjoined
11:31:08  * kesslerquit (Remote host closed the connection)
11:37:36  * kesslerjoined
11:37:53  * freealljoined
11:54:24  * xipliasquit (Quit: Connection closed for inactivity)
12:09:04  * yoshuawuytsquit (Ping timeout: 252 seconds)
12:12:08  * thlorenzjoined
12:16:37  * thlorenzquit (Ping timeout: 264 seconds)
12:22:55  * kesslerquit (Remote host closed the connection)
12:33:44  * thlorenzjoined
12:38:11  * thlorenzquit (Ping timeout: 244 seconds)
12:40:23  * kesslerjoined
12:45:17  * kesslerquit (Ping timeout: 265 seconds)
12:49:20  * kesslerjoined
12:50:34  * thlorenzjoined
12:55:22  * thlorenzquit (Ping timeout: 264 seconds)
12:58:33  * kesslerquit (Remote host closed the connection)
13:05:56  * kesslerjoined
13:09:05  * kesslerquit (Remote host closed the connection)
13:12:24  * pfrazejoined
13:14:53  * fotoveritejoined
13:16:51  * thlorenzjoined
13:22:25  * dguttmanjoined
13:33:28  * yoshuawuyts1joined
13:43:24  * kesslerjoined
13:48:30  * dguttmanquit (Ping timeout: 272 seconds)
13:53:07  * dguttmanjoined
13:56:08  * kesslerquit (Remote host closed the connection)
13:59:16  * kesslerjoined
14:03:34  * kesslerquit (Ping timeout: 245 seconds)
14:04:40  * peutetrejoined
14:04:56  * kesslerjoined
14:07:06  * peutetrequit (Quit: ...)
14:12:19  * yoshuawuyts1changed nick to yoshuawuyts
14:17:09  * peutetrejoined
14:19:01  * yoshuawuytsquit (Ping timeout: 264 seconds)
14:21:06  * yoshuawuytsjoined
14:23:49  * dawuudquit (Ping timeout: 264 seconds)
14:23:57  * dawuudjoined
14:29:13  * kesslerquit (Remote host closed the connection)
14:37:47  * pfrazequit (Remote host closed the connection)
14:41:45  * pfrazejoined
14:51:47  * freeallquit (Remote host closed the connection)
14:53:13  * freealljoined
14:54:23  * peutetrequit (Quit: ...)
14:54:42  * reqsharkquit (Quit: Be back later ...)
14:55:25  * kesslerjoined
14:57:41  * freeallquit (Ping timeout: 250 seconds)
14:59:12  * pfrazequit (Remote host closed the connection)
14:59:33  * kesslerquit (Remote host closed the connection)
15:00:59  * kesslerjoined
15:05:49  * kesslerquit (Remote host closed the connection)
15:06:58  * kesslerjoined
15:08:35  * anvaka_quit (Remote host closed the connection)
15:09:09  * anvakajoined
15:09:44  * tilgovijoined
15:13:11  * anvakaquit (Ping timeout: 244 seconds)
15:15:37  * thlorenzquit (Remote host closed the connection)
15:17:00  * kesslerquit (Remote host closed the connection)
15:24:47  * anvakajoined
15:35:19  * pfrazejoined
15:43:28  * yoshuawuytsquit (Ping timeout: 256 seconds)
15:49:08  * reqsharkjoined
16:00:12  * dguttmanquit (Quit: dguttman)
16:09:07  * anvakaquit (Remote host closed the connection)
16:09:40  * anvakajoined
16:13:56  * anvakaquit (Ping timeout: 240 seconds)
16:16:25  * thlorenzjoined
16:21:25  * thlorenzquit (Ping timeout: 264 seconds)
16:21:46  * knownasilyajoined
16:25:31  * thlorenzjoined
16:27:18  * kesslerjoined
16:29:20  * tilgoviquit (Remote host closed the connection)
16:34:35  * kesslerquit (Remote host closed the connection)
16:35:09  * kesslerjoined
16:35:53  * kesslerquit (Remote host closed the connection)
16:57:28  * kesslerjoined
17:08:04  * kesslerquit (Remote host closed the connection)
17:08:39  * kesslerjoined
17:10:25  * thlorenzquit (Remote host closed the connection)
17:10:56  * thlorenzjoined
17:12:15  * jxsonjoined
17:17:32  * anvakajoined
17:22:34  * anvakaquit (Ping timeout: 272 seconds)
17:27:49  * pfraze_joined
17:28:01  * pfrazequit (Ping timeout: 264 seconds)
17:32:50  * kesslerquit (Remote host closed the connection)
17:36:49  * phatedjoined
17:38:19  * kesslerjoined
17:44:03  * dguttmanjoined
18:08:39  * thlorenzquit (Remote host closed the connection)
18:09:01  * thlorenzjoined
18:22:22  * peutetrejoined
18:29:44  * sethvincentjoined
18:31:13  <noffle>tixz: can't repro here. is the server req,res callback being hit? do a console.dir on the request and poke around.
18:31:39  * thlorenz_joined
18:32:37  <tixz>noffle: sorry should have done an update. Turned out to be some crappy Cisco VPN software eating all OPTIONS requests. Super strange...
18:35:19  * thlorenzquit (Ping timeout: 256 seconds)
18:35:54  * thlorenzjoined
18:39:08  * thlorenz_quit (Ping timeout: 256 seconds)
18:47:44  * thlorenzquit (Ping timeout: 245 seconds)
18:47:57  * kanzurequit (*.net *.split)
18:47:58  * ircretaryquit (*.net *.split)
18:47:58  * sz0quit (*.net *.split)
18:47:58  * mk30quit (*.net *.split)
18:47:59  * marcello4dquit (*.net *.split)
18:47:59  * cubertquit (*.net *.split)
18:47:59  * pfraze_quit (*.net *.split)
18:48:01  * hij1nxquit (*.net *.split)
18:48:01  * harrowquit (*.net *.split)
18:48:14  * peutetrequit (Quit: ...)
18:48:31  * thlorenzjoined
18:49:24  * pfraze_joined
18:49:24  * hij1nxjoined
18:49:38  * kanzurejoined
18:49:38  * ircretaryjoined
18:49:38  * sz0joined
18:49:38  * mk30joined
18:49:38  * marcello4djoined
18:49:38  * cubertjoined
18:49:58  * kanzurequit (Max SendQ exceeded)
18:50:05  * harrowjoined
18:50:13  * kanzurejoined
18:50:51  * pfrazejoined
18:52:16  * pfraze_quit (Ping timeout: 259 seconds)
18:59:43  * pfrazequit (Remote host closed the connection)
19:05:45  * anvakajoined
19:08:14  * pfrazejoined
19:09:21  * pfrazequit (Remote host closed the connection)
19:09:43  * thlorenzquit (Remote host closed the connection)
19:10:15  * thlorenzjoined
19:10:19  * anvakaquit (Ping timeout: 250 seconds)
19:18:50  * hij1nxquit (*.net *.split)
19:19:18  * hij1nxjoined
19:21:47  * sethvincentquit (Ping timeout: 256 seconds)
19:26:34  * htdfjtjoined
19:27:43  * contrahaxquit (Quit: Sleeping)
19:35:29  * htdfjtpart
19:39:31  * shamajoined
19:42:11  * yoshuawuytsjoined
19:56:21  * thlorenz_joined
19:58:19  * kesslerquit (Remote host closed the connection)
19:59:26  * thlorenzquit (Ping timeout: 246 seconds)
20:08:43  * jxson_joined
20:08:55  * jxson_quit (Read error: Connection reset by peer)
20:09:23  * jxson_joined
20:12:10  * jxsonquit (Ping timeout: 272 seconds)
20:13:38  * jxson_quit (Remote host closed the connection)
20:14:54  * jxsonjoined
20:14:57  * jxsonquit (Remote host closed the connection)
20:15:29  * jxsonjoined
20:35:10  <rook2pawn>silly question but why would this work only once on a request http://curlpaste.us/id/jc775k ?
20:36:02  <rook2pawn>where the above codde mirrors what is typed to the caller
20:39:32  * pfrazejoined
20:47:44  * pfrazequit (Read error: Connection reset by peer)
20:48:19  * pfrazejoined
20:53:37  * pfraze_joined
20:54:03  * anvakajoined
20:54:56  * pfrazequit (Ping timeout: 240 seconds)
20:58:37  * anvakaquit (Ping timeout: 264 seconds)
21:02:35  * pfraze_quit (Ping timeout: 264 seconds)
21:09:34  * thlorenzjoined
21:12:44  * thlorenz_quit (Ping timeout: 245 seconds)
21:22:52  * pfrazejoined
21:25:56  * tilgovijoined
21:40:15  * thlorenzquit (Remote host closed the connection)
21:47:05  * thlorenzjoined
21:50:25  <jjjohnny>substack: the DHT k/v store looks like a bust
21:50:29  * thlorenzquit (Remote host closed the connection)
21:51:06  * thlorenzjoined
21:51:47  <jjjohnny>and the DHT would bomes like the bitcoin bockchain, a massive download
21:52:03  <jjjohnny>/s/bomes/becomes
21:52:41  <jjjohnny>/s/\s/\/bomes\/becomes/\s/\bomes\/become
21:53:10  <jjjohnny>song it with me now
21:54:16  <substack>jjjohnny: it's not permanent, nodes need to reannounce every 2 hours for content they want to stay alive
21:55:14  <jjjohnny>substack: a fast moving metadatabase on a worldwide p2p fungible DHT sounds like asking for trouble
21:55:41  <jjjohnny>one node takes something down, another puts it up
21:56:24  <jjjohnny>but i am naive of the implementation deets
21:58:17  <jjjohnny>and it is easily attackable
21:59:15  <substack>there are some other DHTs that might not have these problems, but I need to research them more
21:59:46  <substack>and I don't know much about how you can use gossip protocols to do the same kinds of tasks
21:59:57  <substack>how the routing works in particular
22:02:35  <jjjohnny>afaik it is about having some percentage of peers replicate. domanic probably has stats on tuning. they replicate with a max 20 peers with "friends", altho i'm not certain of those details either
22:03:43  <jjjohnny>some magic number of relays gets you everything gauranteed
22:04:07  <jjjohnny>if we are mostly gettings our links from friends, tho
22:04:12  <jjjohnny>and sharing metadata with friends
22:04:59  <jjjohnny>ina p2p net, your cyber identy is more associated with your peers than your browsing habits
22:05:27  <jjjohnny>i'm not making the connecton jjjohnny
22:05:38  <jjjohnny>me neither
22:05:55  * yoshuawuyts1joined
22:07:00  <jjjohnny>seems safe to use gossips, secure and coinciedentally efficient
22:07:35  * yoshuawuytsquit (Read error: Connection reset by peer)
22:07:40  <jjjohnny>NOW WHO WANTS TO BE MY FRIEND?
22:08:02  <jjjohnny>hackistan has rooms open again BTW FYI
22:13:39  * kesslerjoined
22:30:32  * freealljoined
22:42:14  * anvakajoined
22:46:55  * anvakaquit (Ping timeout: 256 seconds)
22:50:05  * kesslerquit (Remote host closed the connection)
23:02:17  * thlorenzquit (Remote host closed the connection)
23:06:43  * sethvincentjoined
23:13:09  * knownasilyaquit (Quit: Connection closed for inactivity)