5 years and $300 million in investor money later and IPFS is still not useable for website hosting.


Personally, I'm disappointed. Guess I'll start poking more at dat:// but I'm not happy with how it barely got any implementation outside the browser.

@polychrome IPFS, Dat, cjdns, …

All these nice ideas for decentralizing the web but nobody wants to use them.

Maybe, just maybe, it’s not such a bad idea to write your reference implementation as a library with a C API and write some proper cross-platform tooling so people can actually use it. Not Node.js or Go. Jesus fucking christ.

@polychrome BitTorrent worked out because there are clients people are willing to use (though the shitty one-click-hosters and streaming sites are still way more popular). Setting up IPFS is too painful.

@lachs0r webclients are fine for quick work bursts.

Anything involving actual or long term work, gimme native clients - preferably in C. (I'll let Rust slide too)

@polychrome A reference implementation should always favor portability and reusability, so it absolutely must have a C API. Everything else will just stall progress forever. There are countless examples for this.

@lachs0r @polychrome Rust code with a C API is absolutely possible. Rust’s C FFI is quite good.

@alexbuzzbee @polychrome Only feasible if it’s entirely self-contained and uses no crates. Rust’s ecosystem is terrible.

Frankly, I don’t see the appeal. Writing Rust code feels like filing tax reports to me, and for very little benefit. It literally only has safety going for it, and even that is questionable in a library that needs to call so much platform-specific stuff. Certainly not worth the horribly convoluted architecture that it encourages.

And call me when Rust actually works on more than 2 or 3 architectures. Support for anything but x86 targets is extremely poor.

@lachs0r @polychrome I personally find Rust much nicer than C. It’s mostly a matter of the approach you take. I’m not going to dictate to your preferences, but I am going to ask why you consider Rust’s *ecosystem* bad.

At least in my opinion, safety is a very important benefit. Most security bugs are because of memory-safety issues, and security is very important. Rust doesn’t magically prevent all bugs, but it does make a lot of the worst ones much less likely.

So people with no c experience shouldn't work on distributed systems, or people with no c experience should write shoddy c to get adoption or are we just going with people with no c experience shouldn't program at all?

@iMartyn @polychrome No. And C isn’t even hard to learn. You can do it on a weekend (I did, anyway). The really hard part is problem solving skills, especially if you don’t intuitively grasp concepts like pointers (but then you shouldn’t be writing software, whether you need them in your language or not, because you will not be able to understand the tools you’re working with, especially in systems programming).

Utterly disagree, and I've worked with many languages over the years. C is difficult to write well, more difficult to write clean readable code in and just a barrier that is completely unnecessary. A lot of modern languages are better in many regards and language extremism is a really bad thing. Claiming that people who don't intuitively grasp pointers can't grok systems programming is just hubris.

@lachs0r The first commercial program I wrote had "for Windows" in the title, so if it is, you need to adjust your calibration. @polychrome

@iMartyn @polychrome Then, unless you were wildly incompetent at your job, you should have noticed just how futile any attempt to use system APIs without understanding pointers is. You simply cannot ignore them. If you don’t understand pointers, you have no hope of understanding systems. I am willing to die on this hill.

Also, they’re such a simple and basic concept that if you don’t even understand THOSE, how will you ever solve any substantial software problem without copying and pasting shit from SO? That’s my actual point. Not the pointers themselves are important, but the way of thinking about problems that you need to acquire in order to understand them in the first place.

@lachs0r You said "intuitively grasp", VERY different. You made that distinction, not me. And I actually disagree, albeit I think our definitions of "systems programming" are somewhat askew, and I think you read "systems programming" when I said "programming", which made your "all of the above" response come off as elitist and shitty.

@iMartyn No, I actually mean it, but not due to language elitism but because C simply is the language systems and a lot of important software is written in. And most importantly, it’s still the thing that glues everything together. Some experience with it is indispensable.

@lachs0r well if you truly believe that if you don't learn C, you shouldn't program at all, you're kidding yourself that you're not elitist. Look at the kids of today who start with scratch and on to python, and you think that they should jump straight from scratch to C, or stop? That is not the kind of attitude that will lead to the next generation of devs. Time changes and yes, this might lead to 2-tier dev stuff but better that than the alternative. all IMHO of course.

@iMartyn @lachs0r

You've created a flow chart:
1. No C experience, don't do it.
2. Obtain C experience.
3. Do it shoddily so someone will get mad and make a better one :blobcatinnocent:

@lachs0r @iMartyn
Making distributed systems is hard. If you can't make a C API, you're probably not even close to qualified.

@iMartyn @lachs0r @polychrome
I2P and Freenet also both suffer from being written in a language (Java) that doesn't like to interoperate. As such they've remained niche.

I think I2C may finally have an implementation with a C API at least.

Sign in to participate in the conversation

Tōhō, socialism, and a cute mouse.