jmill has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
jmill has joined #ipfs
jmill has quit [Client Quit]
_whitelogger has joined #ipfs
dconroy has joined #ipfs
<homelessrobot[m]>
bitbit: yes sorta. IPFS proper does not, because its static, but ipns lets you 'point' to ipfs trees, so you can swap the tree out, and have the new tree point to the old tree.
<bitbit>
homelessrobot[m]: but how is that allowed from a security stand point? because you actually go looking for one hash and somehow you're supposed to figure out there are alternate hashes to choose from
<homelessrobot[m]>
because its ipns isn't based on hashes. they are like git refs, they 'refer to' parts of the ipfs tree. IDK the specific details, but an IPNS name is like a public keyid, and the ref it points to is signed by the private part (or something like that)
<homelessrobot[m]>
or the hash it points to
<homelessrobot[m]>
its two different systems (ipfs and ipns) serving two different functions in a complementary way.
<homelessrobot[m]>
one references, and one data
<homelessrobot[m]>
both are a part of the ipfs tools and network though
<homelessrobot[m]>
neither natively knows anything about revisions, but its easy to encode revisions into ipfs once you have ipns to change the 'head' ref of your data structure
jmill has joined #ipfs
<homelessrobot[m]>
(i am no expert though, some of this might not be totally true)
jmill has quit [Ping timeout: 276 seconds]
<bitbit>
homelessrobot[m]: I'm guessing that only the owner can change the head ref. I am wondering if theres a way for others to publish to the network their revisions
<homelessrobot[m]>
sure, you can embed ipns names/references in ipfs. So the owner can incorporate contributor refs into their tree, the individual contributors can change what their refs point to, and it all contributes to the interpreted structure of the tree.
<homelessrobot[m]>
like in a filesystem interpretation. root owns the tree. but he might make a symbolic link into a user's home folder, and it gets interpreted like the user is making changes to the tree, even though the tree is physically unchanged.
<bitbit>
homelessrobot[m]: I understand why today it is asking permission of the owner, but ultimately you would want ownership not to matter as much as trust between peers
jkilpatr has quit [Ping timeout: 260 seconds]
<homelessrobot[m]>
you could hypothetically construct such a trust system in ipfs/ipns, but they don't provide it out of the box. but none of what we are discusssing is really 'out of the box' beyond the basic function of ipns and ipfs
droman1 has quit []
jmill has joined #ipfs
<homelessrobot[m]>
you would have to establish what trust even means in the context of maintaining a patch history of some arbitrary data structure first. The most obvious sort of trust would be ownership of some ipns name.
subtraktion has joined #ipfs
subtraktion has quit [Client Quit]
<homelessrobot[m]>
but i think constructing more nuanced/complicated trust models could definitely benefit from these primitives
dconroy has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
jmill has quit [Ping timeout: 276 seconds]
<bitbit>
I see
dimitarvp has quit [Ping timeout: 276 seconds]
dconroy has joined #ipfs
jmill has joined #ipfs
jmill has quit [Client Quit]
chungy has quit [Read error: Connection reset by peer]
chungy has joined #ipfs
jmill has joined #ipfs
<homelessrobot[m]>
but i think any sort of organic/heuristic consensus about trust is outside of the scope of ip(f/n)s. You would have to give some oracle the ipns key, let it work its squishy magic, and then publish to the ipns name the results of the consensus. It might look at ipfs data to do this, and output ipfs data when its done, but i don't think the ipfs network itself could help make those peer trust decisions.
<bitbit>
indeed. I've since found the Beaker browser and Dat. seems promising. they are planning to make a trust network in the browser
jmill has quit [Ping timeout: 240 seconds]
<homelessrobot[m]>
yeah. we live in interesting times, lots of cool new crypto-decentralized things popping up
jsgrant has joined #ipfs
<homelessrobot[m]>
me and a couple of other guys are discussing an idea about how to make something like https://keybase.io live on top of ip(f/n)s. it'd serve as a way to connect external names and identities to each other, and to ipns, and build a kind of trust graph out of them.
Akaibu has joined #ipfs
<bitbit>
homelessrobot[m]: the real challange I believe is to improve you revision auditing. today the best we have is a diff view tool. we need something more visual to audit software and replace premission alerts
<bitbit>
and merge conflicts
<bitbit>
because the only way the network can verify trust is with tools that are easy to use daily
jmill has joined #ipfs
<homelessrobot[m]>
right. I think merging conflicts comes down to the revisions having more internal structure than "i inserted some text here, and removed some text here". Like, the rcs is aware of the structure of the thing you are editing beyond it just being text
<homelessrobot[m]>
so if its a c++ program, the rcs knows about the structure of c++ programs
<bitbit>
yes we need a revision control system that takes advantage of machine learning for detecting similarities, and even for understanding hierarchy
<homelessrobot[m]>
im thinking more along the lines of !wikipedia structure_editor
<deltab>
in the git model, that understanding is only needed for diff and merge tools
<deltab>
because git stores whole files, regardless of their structure
<homelessrobot[m]>
right
<deltab>
diff and merge are pluggable, selected by the file attributes
<bitbit>
hollowzen[m] how does it tackle the problem? its not very clear from skimming the article
<deltab>
that's why commits are at the level of the whole tree: it doesn't know what depends on what, so it assumes everything depends on everything
<homelessrobot[m]>
its a very oblique association i guess. In the same way that a structure editor wouldn't allow you to input something that isn't a valid structure (program), the revision control system could also operate over those structures, rather than their textual representationf
<homelessrobot[m]>
not allowing you to even commit a malformed structure (program)
* deltab
nods
<homelessrobot[m]>
and if some measure of wellformedness is guaranteed, you can do really smart things
<deltab>
but even ensuring the syntax stays right, there can be semantic dependencies
<homelessrobot[m]>
sure
<homelessrobot[m]>
it doesn't need to be validating everything, just something more than nothing
<homelessrobot[m]>
it could even just tokenize the input, and operate on tokens rather than raw text. like number literals, variable names, keywords
<bitbit>
that is why I think the ultimate is ML... make the code into a graph, have a viewer for the graph, show diffs on the graph, debug on the graph, program on the graph...
<bitbit>
graph = mental model we already have in our heads when doing debugging or creating new app
<homelessrobot[m]>
but this all sacrificies some generality for 'smartness'. and making that sacrifice disappear into the background is the tough problem
<bitbit>
exactly... validating lines of code is the pain point. it turns it into a UX problem
<homelessrobot[m]>
like with structured editors. your program has to meet some measure of wellformedness to even be saved to disk. So you couldn't write half of an expression and go get some coffee
<bitbit>
if we've learned anything from XHTML and other such things... asking for complexity never gets popular
* homelessrobot[m]
nods
<bitbit>
look at yarn vs npm... what is the advantage of yarn? you get to write "yarn add xyz --dev" instead of "npm install xyz --save-dev" ... that and a bit quicker install time is enough for devs to move to yarn from npm
<bitbit>
I'm facinated with how you could capture the hierarchy and intent of a mental model in a Machine learning model. I think probably to use something like time-series to express each level of abstraction... not sure if that makes sense
enzo__ has joined #ipfs
<homelessrobot[m]>
like a programming language that is ML derived from some pseudo code, then you compile the psuedo code with that derivation XD
<homelessrobot[m]>
spoooooky
<bitbit>
yes. I mean ML is all about encoding your decisions into models... so it would represent those are probablities. the latest I've found that seems close is what is called 'fuzzy logic' (see fuzzy.ai)
<bitbit>
those as*
jaboja has quit [Remote host closed the connection]
jeremiah__ has quit [Remote host closed the connection]
anewuser has joined #ipfs
enzo__ has quit [Quit: This computer has gone to sleep]
<homelessrobot[m]>
quite a bit less spooky that i was thinking. But yeah i see how developing this further could make things spookier/more intelligent feeling
<kythyria[m]>
What we've learned from XHTML is that people will bend over backwards to justify parsers that silently do strange things with supposedly malformed input.
<homelessrobot[m]>
"why typecheck today what you can debug into perpetuity?"
<homelessrobot[m]>
which i thinking isn't really a rhetorical question. And the answer is "i don't fully understand my own intentions, so some non-determinism might help me figure them out".
tulior has quit [Ping timeout: 255 seconds]
palkeo has joined #ipfs
Akaibu has quit [Quit: Connection closed for inactivity]
anewuser has quit [Quit: anewuser]
ygrek has joined #ipfs
Maxz has quit [Read error: Connection reset by peer]
TheGuyWho has quit [Ping timeout: 240 seconds]
TheGuyWho has joined #ipfs
jmill has joined #ipfs
jmill has quit [Ping timeout: 240 seconds]
libman has quit [Quit: Connection closed for inactivity]
Caterpillar has joined #ipfs
palkeo has quit [Ping timeout: 276 seconds]
<_mak>
is it possible to get ipfs output in json format?
Maxz has joined #ipfs
owlet has quit [Ping timeout: 240 seconds]
rendar has joined #ipfs
bingus is now known as K0las
K0las is now known as bingus
bingus is now known as Lxnowe
Lxnowe is now known as lxrowe
kythyria[m] is now known as Kydrone
lxrowe is now known as bingus1
Kydrone is now known as Kythyria[m]
bingus1 is now known as bingus
robattila256 has quit [Ping timeout: 255 seconds]
_whitelogger has joined #ipfs
<_mak>
with the pubsub feature, is it possible to read from a sub and exit? I'm running it from inside a script and I want to get just 1 message from the sub and then resume the script execution.
dimitarvp has joined #ipfs
limbo_ has joined #ipfs
<limbo_>
Is there anything that'd let me share a diectory using ipfs like the autoindex module in nginx and apache?
<limbo_>
Also, what's the average overhead for doing this, in terms of data transferred and latency?
maxlath has joined #ipfs
chungy has quit [Ping timeout: 240 seconds]
zuck05 has quit [Ping timeout: 240 seconds]
ralphtheninja has joined #ipfs
zuck05 has joined #ipfs
Foxcool has joined #ipfs
dimitarvp has quit [Ping timeout: 240 seconds]
dimitarvp has joined #ipfs
sirdancealot has quit [Ping timeout: 240 seconds]
ygrek has quit [Ping timeout: 255 seconds]
pat36 has joined #ipfs
reit has quit [Remote host closed the connection]
reit has joined #ipfs
maxlath has quit [Ping timeout: 255 seconds]
mildred3 has joined #ipfs
dimitarvp has quit [Ping timeout: 240 seconds]
_whitelogger has joined #ipfs
mildred3 has quit [Ping timeout: 276 seconds]
jmill has joined #ipfs
jmill has quit [Ping timeout: 246 seconds]
_whitelogger has joined #ipfs
Encrypt has joined #ipfs
Encrypt has quit [Client Quit]
Encrypt has joined #ipfs
_whitelogger has joined #ipfs
_whitelogger has joined #ipfs
_whitelogger has joined #ipfs
dimitarvp has joined #ipfs
wrouesnel_ is now known as wrouesnel
zuck05^ has joined #ipfs
zuck05 has quit [Ping timeout: 268 seconds]
jmill has joined #ipfs
jmill has quit [Ping timeout: 276 seconds]
maxlath has joined #ipfs
Miezel has joined #ipfs
Encrypt has joined #ipfs
o33 has joined #ipfs
zuck05 has joined #ipfs
zuck05^ has quit [Ping timeout: 255 seconds]
pat36 has quit []
Mateon2 has joined #ipfs
Mateon1 has quit [Ping timeout: 248 seconds]
Mateon2 is now known as Mateon1
Miezel has quit [Quit: This computer has gone to sleep]
<_mak>
what is the pattern to consume a message from 'ipfs pubsub sub channel' given that ipfs will keep running even after the message is received? how should I pass it to the client that is waiting for the messagE?
<_mak>
is it possible to get one message at a time?
Miezel has quit [Quit: This computer has gone to sleep]
jmill has joined #ipfs
jmill has quit [Client Quit]
rcat has joined #ipfs
xa__ has joined #ipfs
xa__ has left #ipfs [#ipfs]
Encrypt has quit [Quit: Quit]
owlet has joined #ipfs
ralphtheninja has quit [Ping timeout: 260 seconds]
pat36 has joined #ipfs
jmill has joined #ipfs
jmill has quit [Client Quit]
robattila256 has joined #ipfs
arpu has quit [Ping timeout: 268 seconds]
jmill has joined #ipfs
jmill has quit [Client Quit]
jkilpatr has joined #ipfs
A124 has quit [Ping timeout: 248 seconds]
A124 has joined #ipfs
chungy has joined #ipfs
rtjure_ has joined #ipfs
rtjure has quit [Ping timeout: 276 seconds]
rtjure_ has quit [Ping timeout: 260 seconds]
<deltab>
limbo_: yes, autoindex is done by gateways when they display directory objects
dconroy has quit [Read error: Connection reset by peer]
<deltab>
limbo_: the overhead is larger than it needs to be on the http side because of all the embedded icons, but that should be easy enough to fix
christop1ler has joined #ipfs
citizenErased has joined #ipfs
citizenErased has quit [Remote host closed the connection]
yosafbridge has quit [Quit: Leaving]
yosafbridge has joined #ipfs
palkeo has joined #ipfs
palkeo has joined #ipfs
palkeo has quit [Changing host]
rtjure has joined #ipfs
rtjure has quit [Ping timeout: 268 seconds]
palkeo has quit [Ping timeout: 246 seconds]
jmill has joined #ipfs
CrAzYPiLoT has joined #ipfs
jmill has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
rtjure has joined #ipfs
digitalism has quit [Remote host closed the connection]
spread has joined #ipfs
Miezel has joined #ipfs
pedrovian has joined #ipfs
jkilpatr has quit [Ping timeout: 240 seconds]
enzo__ has joined #ipfs
<CrAzYPiLoT>
Hey, uh, my first time using ipfs, looks fantastic, one issue though
<CrAzYPiLoT>
No matter if I run in cmd or powershell, many commands just hang when I run them
<CrAzYPiLoT>
Also, all of them never return me to the command line after they finish, so you can image how painful starting the daemon is
enzo__ has quit [Client Quit]
<deltab>
_mak: pipe into head -n 1 or something?
<deltab>
CrAzYPiLoT: I expect they're waiting for input
<CrAzYPiLoT>
Commands like cat hang too
<CrAzYPiLoT>
I don't see how cat would expect input
ygrek has joined #ipfs
mildred1 has joined #ipfs
<CrAzYPiLoT>
Now I'm curious, I think I might know what the issue is
mildred2 has joined #ipfs
<CrAzYPiLoT>
Is it possible for commands to silently fail if the user cannot receive packets?
<CrAzYPiLoT>
Say, if the user is behind a CGNAT?
mildred1 has quit [Ping timeout: 240 seconds]
<r0kk3rz>
CrAzYPiLoT: afaik most of the commands have a fairly long timeout
Maxz has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
<r0kk3rz>
but cat is going away and doing things on the network, which can be slow
jmill has joined #ipfs
<CrAzYPiLoT>
So, it is then, I recently found out my ISP put people behind a CGN, and it never crossed my mind that, just as I can't seed torrents, I can't participate in ipfs
<CrAzYPiLoT>
I mean, I let it do its thing for 2-3 minutes, it probably should be done by then
<CrAzYPiLoT>
It's not that slow, is it?
<r0kk3rz>
depends on what you're doing
<r0kk3rz>
but the CGNAT wont help things, it will mean you're only able to talk to nodes on your ISP maybe
jmill has quit [Ping timeout: 246 seconds]
<CrAzYPiLoT>
Most likely only my local network. There go my hopes of actually helping dev of decentralized internet
<CrAzYPiLoT>
Though, I'll probably get a static IP and be freed of CGN soon, so there's a glimmer of hope ;)
<Mateon1>
_mak: Yes, the ipfs command accepts "--enc=json" as a parameter, so `ipfs --enc=json pubsub sub topic` returns what you want. Note: All fields are base64 encoded
tilgovi has joined #ipfs
<Mateon1>
(only in the case of pubsub, not in general)
<r0kk3rz>
CrAzYPiLoT: there is a way to print out the peers you're connected to, if any
<limbo_>
deltab: are there any tools to recursively add a directory to ipfs?
<CrAzYPiLoT>
Yeah, just did swarm peers, seems I actually am connected to some
<deltab>
limbo_: ipfs add -r
<CrAzYPiLoT>
cat still hangs on any of them, welp
mildred2 has quit [Read error: Connection reset by peer]
mildred2 has joined #ipfs
sirdancealot has joined #ipfs
<Mateon1>
CrAzYPiLoT: Are you trying to cat the peers? You can't do that
<Mateon1>
You can try to `ipfs name resolve Peer`, to see if they published anything to ipns
<_mak>
deltab: it seems that pubsub sub will hold the process, the command won't exit after receiving a message
<_mak>
Mateon1: thanks :)
<_mak>
I wonder how people are using 'pubsub sub' given that there is no easy way to get the messages programatically
<Mateon1>
Well, the HTTP API is a decent way to do so
<Mateon1>
If you have a proper streaming library
<limbo_>
Are there any .debs for ipfs, or do I have to make one myself? I know there's a snappy package.
<_mak>
Mateon1: I could not find a ruby gem that had pubsub implemented :/
Miezel has quit [Quit: This computer has gone to sleep]
<Mateon1>
_mak: Hm, might want to file a feature request on an IPFS API gem
<_mak>
yeah, sounds like an idea
Miezel has joined #ipfs
AndrewMcSwain[m] has joined #ipfs
<CrAzYPiLoT>
Mateon1: yeah that was a stupid move on my side, although the four peers were just the gateway servers; the pluto, neptune, earth deal
<Mateon1>
Yeah, I don't think they publish anything
<Mateon1>
Actually, is earth up? I had trouble accessing it via earth.i.ipfs.io
<Mateon1>
No, earth is up
<Mateon1>
Must have been another node
<Mateon1>
Ah, mars.i.ipfs.io is down
dimitarvp` has joined #ipfs
rendar has quit [Ping timeout: 240 seconds]
<CrAzYPiLoT>
Well, what do you know, I managed to circumvent the CGN with a 6in4 tunnel
dimitarvp has quit [Ping timeout: 248 seconds]
ilyaigpetrov has joined #ipfs
maxlath has quit [Ping timeout: 240 seconds]
m0ns00n has quit [Quit: quit]
Maxz has joined #ipfs
maxlath has joined #ipfs
rendar has joined #ipfs
rendar has quit [Client Quit]
Encrypt has joined #ipfs
ralphtheninja has joined #ipfs
Encrypt has quit [Quit: Quit]
hermanjunge has joined #ipfs
hermanjunge has quit [Client Quit]
hermanjunge has joined #ipfs
hermanjunge has quit [Client Quit]
hermanjunge has joined #ipfs
hermanjunge has quit [Client Quit]
hermanjunge has joined #ipfs
hermanjunge has quit [Client Quit]
hermanjunge has joined #ipfs
hermanjunge has quit [Client Quit]
jsgrant has quit [Ping timeout: 240 seconds]
erde74 has joined #ipfs
Jesin has joined #ipfs
Miezel has quit [Quit: This computer has gone to sleep]
Miezel has joined #ipfs
Miezel has quit [Client Quit]
erde74 has quit [Quit: Verlassend]
enzo__ has joined #ipfs
jaboja has joined #ipfs
mildred2 has quit [Ping timeout: 240 seconds]
mildred3 has joined #ipfs
mikeal_ has joined #ipfs
<mikeal_>
how do I build a directory with files.createAddStream in the JS implementation?
Maxz has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
shizy has joined #ipfs
Maxz has joined #ipfs
tilgovi has quit [Ping timeout: 255 seconds]
pat36 has quit []
maxlath has quit [Ping timeout: 260 seconds]
enzo__ has quit [Quit: This computer has gone to sleep]
shizy has quit [Ping timeout: 246 seconds]
Jesin has quit [Quit: Leaving]
Jesin has joined #ipfs
jaboja has quit [Ping timeout: 268 seconds]
enzo__ has joined #ipfs
tilgovi has joined #ipfs
jmill has joined #ipfs
Caterpillar has quit [Quit: You were not made to live as brutes, but to follow virtue and knowledge.]
<mikeal_>
any special options I need to set to get the p2p stuff working in the browser or should the defaults work?
citizenErased has joined #ipfs
citizenErased has quit [Remote host closed the connection]
enzo__ has quit [Quit: This computer has gone to sleep]
ddd12 has quit [Remote host closed the connection]
ddd12 has joined #ipfs
ddd12 has quit [Max SendQ exceeded]
clavi has joined #ipfs
ddd12 has joined #ipfs
enzo__ has quit [Quit: This computer has gone to sleep]
pcre has quit [Read error: Connection reset by peer]
vic_ has joined #ipfs
tilgovi has quit [Ping timeout: 276 seconds]
tilgovi has joined #ipfs
Nox[Matrix] is now known as Noxarivis
<limbo_>
If you're sharing local content on IPFS, is it discoverable in any way? Like through DHT crawling? Is there any way, other than out of band encryption, to use IPFS for semi-private files?
ilyaigpetrov has quit [Quit: Connection closed for inactivity]
ralphtheninja has quit [Ping timeout: 240 seconds]
Noxarivis is now known as Noxarivis[m]
reit has quit [Quit: Leaving]
cxl000 has quit [Quit: Leaving]
<kpcyrd>
limbo_: yes, it's discoverable, I think there's a search engine around based on that. I'd recommend out of band encryption or running a private ipfs network, depending on your needs
<Magik6k>
limbo_, It is possible to discover stuff in the DHT, for private things there is private network feature
chris613 has left #ipfs [#ipfs]
<limbo_>
Aside from running the daemon twice, is there any way to use public and private networks on the same machine?
r00t_ has joined #ipfs
<r00t_>
hi i was wondering what happens if someone uploads something unwatned to ipfs? is there anyway to remove unwatned content? like idk child porn or smthing not good like that? i guess you would have to take down all the nodes that downloaded it?
<kode54>
or maybe a leaked game console SDK?
<r00t_>
xD
<limbo_>
r00t_: no. Gateways need to keep up to date blacklists, and the content will disappear once no online nodes have it.
<r00t_>
but who decaides which content is blacklisted?
<limbo_>
whoever's running the gateway.
<limbo_>
How do you delete unwanted content from the regular web? Same deal.
tilgovi has quit [Remote host closed the connection]
<limbo_>
Does ipfs have any NAT breaking abilities?
rcat has quit [Quit: leaving]
tilgovi has joined #ipfs
<limbo_>
Looks like it does. Neat. Is there any easy way to determine what nodes are hosting a specific file? By IP address, or something.
<Magik6k>
Yes, though not all NAT combinations are supported yet. There is a relay feature in development that will let nodes talk to each other via a relay node, so NAT will be less of a problem
<Magik6k>
limbo_, for that look at `ipfs dht findprovs`