HNHacker News
TopNewBestAskShowJobs

_prometheus

1,656 karma · joined June 2, 2013

[ my public key: https://keybase.io/jbenet; my proof: https://keybase.io/jbenet/sigs/lpp1GdnY98lmHHuLy5Gg2I6CfIhFOu8qGFjKplz8u70 ]
submissionscomments
_prometheus··on Why the Internet Needs IPFS
(IPFS Dev) Yeah, we have many similarities with Freenet, but we also have significant differences. You mention the lack of anonymity, and yep, that's definitely one -- to speak more about this: this parts from our content model. Among explicit constraints, we have:

- content must be able to move as fast as the underlying network permits. this rules out designs like freenet's and other oblivious storage platforms, as the base case. Like you said, they're just way too slow for most of IPFS use cases. But, these can be implemented trivially with the use of privacy focused transports (like Tor and I2P -- there's actually work towards this and people are getting close), content encryption, and so on.

- IPFS nodes should be able to only store and/or distribute content they _explicitly_ want to store and/or distribute. This means that computers that run IPFS nodes do not have to host "other people's stuff", which is a very important thing when you consider that lots of content in the internet is -- in some for or other -- illegal under certain jurisdictions. Legitimate companies have way too much in their plate to additionally worry about potentially be storing a ton of illegal stuff. For serious companies like Google to use IPFS, we need to have a mode of operation that allows implementations to ONLY move the content THEY want to move.

- Websites/Webapps must be able to operate entirely disconnected -- this means that it should be possible to build applications which create data locally, signed by the user, which can be distributed encrypted end-to-end to other users, without needing to ever touch specific backbone servers. This means users can move the data end-to-end via the closest route possible and in disconnected networks (think users on mobile phones on a plane using messaging webapp or web game and moving the bits over bluetooth or an ad-hoc wifi network. And this also means users in the broader internet do not _need to_ rely on backbone servers -- the model we're going for is that dedicated computers in the backbone CAN of course and SHOULD help, but you shouldn't HAVE TO RELY on them.

Can write more about this :)

_prometheus··on Why the Internet Needs IPFS
(IPFS dev here) Hey! Yeah, we're focusing right now on "distributed static websites" because those are really easy to get right and make work all over the network. However, what's _really_ interesting about IPFS is making completely distributed applications which can do their process unhinged from a single origin -- websites/webapps without an origin server. Posted more about this elsewhere on this thread, take a look: https://news.ycombinator.com/item?id=10329221

Also see the Neocities + IPFS blog post: https://ipfs.io/ipfs/QmTVcD87Ecjps6wv9jMaGhvMuzZ2BgP6NyXDcnM...

Take a look also at this talk, which presents different use cases for this: https://www.youtube.com/watch?v=skMTdSEaCtA

Can also see some of the random crazy things we're planning in https://github.com/ipfs/notes/issues/ + https://github.com/ipfs/archives/issues/ + https://github.com/ipfs/apps/issues/

(Edit: fix links)

_prometheus··on Why the Internet Needs IPFS
(IPFS dev) Yes! One of my explicit goals is to help get to Alan Kay's "one address for each object" goal.
_prometheus··on Why the Internet Needs IPFS
(IPFS dev here) I think subresource integrity is an _awesome_ thing that needs to be implemented and spread all over asap. (Actually, if you work on this, please ping us! we'd love to help!)

However, this is very far from "many of the claimed advantages". I think it covers a few, but take a look at all the other stuff we can do, like making offline/disconnected webapps work! Think of IPFS like git or bitcoin, not just bittorrent.

_prometheus··on Why the Internet Needs IPFS
(IPFS Dev here) hey again tptacek! o/

> I'm not clear on how IPFS protects applications from DDOS. Systems like IPFS spread the load of delivering content, but applications themselves are intrinsically centralized.

Think about an application whose content is moving around entirely distributed by IPFS as well -- think of apps who run mostly on clientside, with signed (+ maybe encrypted) data generated on the users' browsers, with maybe a few "non-browser" nodes contributing to building indices or providing trusted oracles.

What we're taking about is a model for webapps in which not just the content, but the logic + processing is decentralized too. At one extreme are bitcoin/ethereum style applications, where everyone runs the same computation to verify it, and another extreme where everyone just computes on their own data + the data they care about, and sign all their updates.

How to do this well is not easy-- distributing the content is one part, another is making a really good capabilities library (Tahoe-LAFS has done an excellent job with this, for example, and e-rights has tons more great ideas). Another part still is thinking about the sync models with ephemeral nodes which create tons of small pieces of data, blast them out to content bouncers, and go offline. Building scalable real-time indices on this sort of stuff is going to be tricky :)

Another interesting area is thinking about how databases look once you do this-- think both NoSQL AND SQL models on top of IPFS. yep, may sound crazy, but we have some preliminary work towards this (NoSQL is easy, SQL is less easy, but very doable! -- after all a database is just a good datastructure and good algorithms for operating on it).

Happy to write more about this, it's a super interesting model we're exploring.

_prometheus··on Why the Internet Needs IPFS
(IPFS dev here) I think she does, but perhaps the discrepancy may be that she's got a different target audience: the established website owners? Also to be fair, there's not much space in these sorts of articles LOTS gets cut by editors and -- from having done something like this -- you have to hit this absuuuurdly high level and can't sink into details much at all. I'm actually pretty surprised at the level of technical detail in this article -- i would've expected much more to not make it past the "remove jargon - write for the average user" media filter. I've done some interviews / articles that ended up annoyingly waaaaay more high level and completely missed my expected mark. You might want to write to the author, too. :)
_prometheus··on Why the Internet Needs IPFS
(IPFS dev here) "questionable bile"? we'd love your technical feedback. We know we have a ton of things to do better -- but what sort of things are you thinking about? what can we improve on?
_prometheus··on Hosting a simple static site on IPFS
(IPFS author here)

You're hitting on some really hard questions :)

the gist is that you use a "record system" that has some transport guarantees, for example relying on a dht has certain kind of properties, as opposed to relying on pub/sub over trusted nodes. IPFS has this part as pluggable, though we're focusing on a large public DHT first. DHTs are pretty robust today, though yes have weaknesses we're working on.

now, the key is that, on top of that, you build assurances around cryptographic freshness (i.e. "trust this record for a certain amount of time"). of course, "certain amount of time" varies with your notion of time (e.g. NTP, vs blockchain times, etc), so the user gets to set that.

if you're interested in how the "record system" works and will evolve, take a look at https://github.com/ipfs/specs/tree/master/records -- though admittedly this is not complete or exhaustive, as we have A TON to do and are focusing on pushing out reliable code.

_prometheus··on Hosting a simple static site on IPFS
Yes. (IPFS author here)

1. Add a TXT record to DNS <domain> with:

   dnslink="/ipns/QmWGb7PZmLb1TwsMkE1b8jVK4LGceMYMsWaSmviSucWPGG"
2. should be able to use https://ipfs.io/ipns/<domain>

See it in action here: https://ipfs.io/ipns/ipfs.io

WARNING: IPNS is still under dev. it's not robust yet, convergence may not be perfect.

_prometheus··on Neocities is implementing IPFS – distributed, permanent web
see also: https://github.com/cryptix/git-remote-ipfs
_prometheus··on Neocities is implementing IPFS – distributed, permanent web
the caveat of course being that SHA256 may be _broken_. That's when we'd have to upgrade to another hash function.

(We may improve how this upgrade will work down the road by allowing links to link with multiple hashes at the same time, but at this time this has not proved to be necessary, and can be added later)

_prometheus··on Neocities is implementing IPFS – distributed, permanent web
this is why we use multihash -- https://github.com/jbenet/multihash
_prometheus··on Neocities is implementing IPFS – distributed, permanent web
Check out another protocol we (the IPFS creators) are working on: http://filecoin.io
_prometheus··on Neocities is implementing IPFS – distributed, permanent web
Two pieces of (coming soon) good news:

- very soon, you wont need to install anything to use IPFS. it will "just work" with js on today's browsers.

- for best perf, yes, we need browser implementations. and... those have begun :)

_prometheus··on Neocities is implementing IPFS – distributed, permanent web
Thanks for the kind words. :) Come join us! https://github.com/ipfs/
_prometheus··on Neocities is implementing IPFS – distributed, permanent web
Thanks! Help us make it :) -- https://github.com/ipfs/

and, you'll love what we have coming. Soon, you won't need to install ipfs at all :D

_prometheus··on Neocities is implementing IPFS – distributed, permanent web
IPFS is designed with mutability in mind-- think of it like git branches which advance to newer versions. (though you can indeed get rid of version history in that pointer if you want). So, the short answer is "yes, IPFS will work with mutable content just fine", though _how_ the mutability works is a harder, deeper question.

I think the best sources will be the paper, the talks on the website, and the FAQ:

- https://ipfs.io/ipfs/QmR7GSQM93Cx5eAg6a6yRzNde1FQv7uL6X1o4k7... - https://ipfs.io/ - https://github.com/ipfs/faq/issues

_prometheus··on Is Git a Block Chain?
Yep! entirely agreed.
_prometheus··on Is Git a Block Chain?
though it may sounds similar, it's very, very different. take a deeper look at the demo on http://ipfs.io
_prometheus··on Is Git a Block Chain?
> I suspect that there's a way to identify the latest content built into IPFS

Yeah-- the IPNS records have a notion of recency, as well as being able to write version history datastructures (e.g. git)

_prometheus··on Is Git a Block Chain?
Thank you for taking the time to write this explanation :)
_prometheus··on IPFS is a new peer-to-peer hypermedia protocol
yeah double NATs are annoying :)
_prometheus··on IPFS is a new peer-to-peer hypermedia protocol
davidad is one of my favorite people in the world :)

> Toscanini's near MIT, fantastic ice cream.

Much agreed.

_prometheus··on IPFS is a new peer-to-peer hypermedia protocol
that's a base58 encoded multihash: https://github.com/jbenet/multihash/ and https://github.com/jbenet/go-multihash/
_prometheus··on IPFS is a new peer-to-peer hypermedia protocol
> I don't know about @jbenet's particular journey to these ideas

Git is the single largest influence on me. After that, various other papers (all the CAN literature, bitcoin/bittorrent, CRDTs, etc), and conversations with people. in particular, two close friends (jzim, davidad).

> We should give Ralph Merkle a Turing award

I agree! Zooko recently told me that a long while ago they dubbed themselves "Merkle Tree Huggers". I am too!

> Except we shouldn't because he patented Merkle Trees, apparently.

Sigh. patents... :(

_prometheus··on IPFS is a new peer-to-peer hypermedia protocol
> The first step is designing your data to be stored in files, rather than a database

Somewhere in the middle-- ipfs gives you native access to the merkledag datastructure, so you can actually port most databases to using ipfs as a kv-store directly. (think an embedded sqlite or something). and on the other side, maybe you dont need a database. maybe you can just construct the graph of objects you need and write that to ipfs.

> maybe becoming "friends" with another user involves a key exchange?

yep! we've discussed an `ipfs friend` cmd

> Ultimately I think IPFS is a pretty cool concept, one I've kicked around a bit but never fleshed out. Major kudos to Juan and everyone else for taking it on - I look forward to seeing where this goes.

Thank you!! Come help us build it! :)

_prometheus··on IPFS is a new peer-to-peer hypermedia protocol
i recently had the pleasure of hanging out with both zooko and warner and they're both excellent. as @whyrusleeping mentioned, there's lots of room for interop + collaboration on things. (in short, we <3 Tahoe-LAFS)
_prometheus··on IPFS is a new peer-to-peer hypermedia protocol
(EDIT: we've a meetup coming up soon. The SV Ethereum Meetup is hosting an intro to IPFS later this month in San Francisco: http://www.meetup.com/EthereumSiliconValley/events/221350594... come hang out!)

--------------- Hello Everyone! ---------------

@jbenet here. Thanks for all the attention! Did not expect to wake up to this post today :)

The best resources for learning about ipfs are:

- The IPFS Paper: http://gateway.ipfs.io/ipfs/QmR7GSQM93Cx5eAg6a6yRzNde1FQv7uL... (note: DRAFT 3, working on DRAFT 4, lots has evolved.)

- The Alpha Demo: https://www.youtube.com/watch?v=8CMxDNuuAiQ

- The First Tech Talk: https://www.youtube.com/watch?v=Fa4pckodM9g

- The IRC Logs: http://botbot.me/freenode/ipfs/ -- there's so much knowledge in these, we're working on moving it over.

We're working on a bunch of more expository media:

- Specs!! https://github.com/ipfs/specs

- More Demos

- More Talks

- Draft 4 of the paper

But there's only so many hours in a day, and we spend most of our time developing. All the resources will be way more polished as time goes on. Please bear with us as we make these available. In the meantime, ask questions in our new FAQ (below), or in #ipfs on irc.freenode.net -- And we'll be answering questions here too of course.

I've just created: https://github.com/ipfs/faq -- if you ask questions there we can build a knowledge base

IPFS already works-- you can install it and try it out. It's not production ready yet, but it's already very reliable. I use it to move around all sorts of personal files, and we use it to host many websites.

Some people asked about what applications are there now? There's many static websites on ipfs, and some simple webapps. We ship our entire ipfs webui with ipfs itself (turtles all the way down!). In particular, Eris Industries recently made a decentralized YouTube clone using IPFS and their Decerver: https://github.com/eris-ltd/2gather If you see more-- please let us know at https://github.com/ipfs/community so we add it to an index (we just reorged our repos under the github org last week)..

We need to make some more tooling to make web-publishing with ipfs really, really nice. We'll be making that over the next few weeks, so if you're interested in pushing out websites with ipfs-- come talk to us.

Another big use case we're going after is Docker container distribution. We're preparing a whole bunch of demos right now that we'll show off in the next week or two. You can peek at: https://github.com/ipfs/container-demos We can already boot entire VMs and containers over ipfs in <10 seconds :D which makes me really happy. You can boot to ipfs with this makefile: https://gist.github.com/jbenet/76afa70955910a2ed097

If you want to help, the best ways are:

- Come hack with us! We're particularly looking for Go hackers

- Just use it!

- Write applications on top.

- Report issues: https://github.com/jbenet/go-ipfs/issues and so on.

- Help us with docs

- Write another implementation (this is blocked by https://github.com/ipfs/specs/)

Some ipfs community members i've seen posting below are: whyrusleeping, dylankpowers, inconshreveable

Also, IPFS development is sponsored by our company, "Protocol Labs, Inc" -- we also make Filecoin. We are hiring, so check out: http://ipn.io/join (yeah-- we just changed the company name. still need to update ipn.io / get a new domain.)

See you around the tubes! :) - @jbenet

_prometheus··on Hashpipe – Pipe iff the hash matches
Great point!! working towards fixing that (the general problem of safe execution of binaries). signed releases will help.

I will release as self-describing signed package for this soon.

_prometheus··on Hashpipe – Pipe iff the hash matches
many execution contexts don't have perl. i have some <10MB VMs in mind.
← PreviousPage 3 of 7Next →