Deploy to the Decentralized Web with IPFS

Episode Description

Ben Myers and Anthony Campolo explore IPFS, the Interplanetary File System, explaining decentralized web concepts and deploying a website live on stream.

Episode Summary

In this episode of Semantics, host Ben Myers welcomes returning guest Anthony Campolo to explore the Interplanetary File System (IPFS), a peer-to-peer protocol for distributing and permanently storing web content. Anthony begins by distinguishing distributed systems from decentralized ones, using CDNs and torrents as accessible analogies, before explaining how IPFS applies torrent-like technology to create a decentralized file system built around content hashes — unique identifiers that ensure content integrity and permanence. The conversation addresses both the promise and the risks of permanent content, including concerns about abuse, moderation challenges, and the current limitations of the technology's reliability. The pair then move into a hands-on demonstration, initializing an IPFS node, creating a simple HTML page, adding it to the network, pinning it, and viewing it through public gateways. They cap off the session by deploying the same site through Fleek, a Jamstack hosting provider for IPFS that abstracts away complexity like IPNS naming and gateway management. Anthony closes by encouraging web developers to explore IPFS as a learning exercise, noting that while it isn't production-ready for most use cases, the underlying mental models — content addressing, gateways, and decentralized permanence — represent a lasting direction for the web.

Chapters

00:00:00 - Introduction and Guest Welcome

Ben Myers opens the stream and reintroduces Anthony Campolo as the original Semantics guest, reflecting on their past episodes covering topics like Redwood, Vite, and Deno. Anthony has a track record of pushing the show beyond its usual focus on accessibility and core web technologies, and this episode is no exception.

Ben sets up the topic of the day — the decentralized web and IPFS — acknowledging that he's well outside his comfort zone. He frames the conversation as an exploration of why web developers should care about these concepts, teeing up Anthony's explanation of the foundational terminology.

00:02:00 - Distributed vs. Decentralized Systems

Anthony breaks down the critical distinction between distributed and decentralized systems. A distributed system spreads computation across many machines, but may still have a single point of control, like a CDN operated by one company. A decentralized system removes that central authority entirely, relying on protocols that let independent nodes coordinate without any one actor in charge.

Ben offers the CDN analogy to ground the explanation, and Anthony extends it by discussing his work at QuickNode, a blockchain infrastructure company. He explains the pragmatic middle ground: centralized services can provide onboarding and convenience while preserving the underlying benefits of decentralization, since users remain free to run their own nodes at any time.

00:05:07 - What Is IPFS and How Does It Work?

Anthony introduces IPFS by comparing it to BitTorrent — a familiar peer-to-peer system — but aimed at distributing files and git-like version-controlled content rather than pirated media. He credits Juan Benet and Protocol Labs for building the system, which enables content to be stored across many nodes so it can't easily be censored or taken down.

Ben summarizes the concept as "GitHub meets BitTorrent," and Anthony refines the analogy by noting that Git was already somewhat decentralized across individual machines, but IPFS takes the idea further by connecting those machines through an Internet-accessible protocol. This distinction — from isolated copies to a networked, content-addressed system — is what makes IPFS fundamentally different.

00:11:13 - Use Cases, Limitations, and the Promise of Permanence

The conversation shifts to practical questions: what kinds of sites can you deploy on IPFS, and what makes it different from traditional hosting? Anthony explains that IPFS is essentially a file system where you can store any files, including HTML, but cautions that the technology is not production-ready due to variable gateway reliability and the overall immaturity of the ecosystem.

Anthony highlights permanence as IPFS's killer feature, explaining how content-addressed hashing solves problems like link rot and content tampering. Ben raises important counterpoints about the risks of permanent content, including doxing and revenge porn. Anthony acknowledges these concerns and predicts that moderated sub-networks will eventually emerge, while noting the deep philosophical tensions inherent in building systems designed to resist censorship.

00:20:25 - Hands-On: Initializing IPFS and Adding Content

The pair move into a live coding demo, starting with the IPFS command-line tools. Anthony walks Ben through initializing a local IPFS repository, examining peer identity, and running the IPFS daemon to connect the node to the broader network. They explore the default readme files that ship with an IPFS installation, demonstrating how the cat command reads content via content hashes.

Anthony explains how content hashes work as globally unique identifiers — both directories and individual files get their own hashes, and changing even a single character produces a completely different hash. This content-addressing model is the foundation of everything IPFS does, from ensuring data integrity to enabling permanent links.

00:32:15 - Creating and Deploying an HTML Page to IPFS

Ben creates a simple HTML page with proper accessibility basics — a lang attribute, UTF-8 encoding, viewport settings, and semantic markup — then adds it to the IPFS network using the ipfs add -R command. They get two content hashes back, one for the file and one for the directory, and verify the content through the terminal's cat command.

They then attempt to view the page through public gateways like ipfs.io and Cloudflare's IPFS gateway. When the content doesn't immediately appear, Anthony explains the importance of pinning — without it, content gets garbage-collected off the network. After pinning the content and checking it via the IPFS Desktop GUI, the site finally loads through a gateway, marking a successful deployment.

00:46:11 - Deploying with Fleek: The Netlify of IPFS

With about fifteen minutes left, Anthony pivots to deploying the same site through Fleek, a Jamstack hosting service built for IPFS. Ben creates an account, connects his GitHub repository, and deploys the site in a process that closely mirrors the Netlify experience — choose a repo, pick a branch, and hit deploy.

Anthony explains what Fleek abstracts away: IPNS (the Interplanetary Name System) for stable URLs despite changing content hashes, reliable gateway access, and automatic redeployment on git push. He contrasts Fleek's consistent performance with the inconsistent results he experienced using raw gateways, making the case that a hybrid centralized-decentralized approach is the most practical path for developers who want to start building on IPFS today.

00:58:22 - NFTs, Future Outlook, and Closing Thoughts

Ben asks about the relationship between IPFS and NFTs, and Anthony explains that an NFT is a unique identifier on a blockchain that can point to content anywhere — including an S3 bucket or a database — but only truly delivers on its promise of permanence when it points to an IPFS content hash. This distinction matters for anyone investing in NFTs.

Anthony closes with advice for web developers: if you're practical and just want to ship products, IPFS isn't urgent yet, but if you enjoy learning new mental models, the core concepts of content addressing and gateways are stable enough to invest in now. He predicts IPFS will eventually integrate seamlessly with the traditional web, becoming invisible to end users. Ben wraps the stream by thanking Anthony and promoting upcoming episodes.

Transcript

00:00:01 - Ben Myers

Howdy. Howdy, y'all. Happy Tuesday. Welcome to Semantics, a stream about building great user experiences for the web with a focus on accessibility and core web technologies. I'm your host, Ben Myers, and today we are rejoined by the OG guest, Anthony Janthony, Kanthony, web developer himself. Welcome back to the stream, Anthony. All right.

00:00:22 - Anthony Campolo

That's the first time I've heard you say Anthony Janthony. [unclear], only. So you type it so far?

00:00:28 - Ben Myers

I mean, what else could AJC stand for? Honestly, nothing.

00:00:33 - Anthony Campolo

Absolutely nothing. It's the only thing.

00:00:35 - Ben Myers

It's the only thing. I call you the OG because you were the first ever Semantics guest. You joined the stream and we talked a lot about Redwood and accessibility and documentation and stuff like that. But you've been on a couple more times, and every time you've kind of pushed the envelope of what I would consider a semantic stream. Um, like, thanks to you, we've done streams on Vite and on Deno and stuff like that. Things I wouldn't usually consider within the Semantics purview.

00:01:04 - Anthony Campolo

And what's funny is, I remember when I was pitching those topics to you, I was like, these things are probably going to be a big deal, like, more so than they are right now. And I think, like, both Vite and Deno, that is proven to be true.

00:01:17 - Ben Myers

Yes, absolutely. So I've put a link to a couple of your. Your past streams in the chat. I. I might have. Oh, I did miss one, actually. Hang on. It was accessible routing. There we go. So this is, I believe, number five for you. But, yeah, so today we are talking about something in which I will freely admit I'm very outside of my element here, which is the decentralized web. Right. The distributed web and specifically interplanetary file system. So I guess let's kind of talk about that. Like, what do those concepts mean to you? And why should web developers find those interesting?

00:02:00 - Anthony Campolo

Yeah, I think first, teasing apart the difference between what does it mean for something to be distributed versus decentralized is a good thing, because when I was first getting into this kind of stuff, I would read all these ideas and hear these words and actually first got into this stuff before I really, like, knew how to code at all. Like, I've been very interested in kind of like the Web3. I actually wrote, like a blog post about Web3 back in 2018. So a lot of people don't really realize the term web3 is not actually super new. It's. It's been around for at least five years. If not longer. But the idea is that we want to have systems that are kind of across multiple computers in multiple geographic regions. And that can be something that is distributed because it's literally a bunch of computers talking to each other, and they're distributed across the world. Now, for something to be decentralized, though, means that they're not all being connected to a single point of control. So you can have a distributed system that has kind of like a single central actor that is kind of keeping it all together and telling them all what to do and keeping the data stored somewhere and all that.

00:03:14 - Anthony Campolo

Or you can have a system where there's a protocol that involves multiple computers talking to each other and there is no kind of central actor that's in control of the system. So that's what makes something decentralized. So then think about it.

00:03:29 - Ben Myers

An example of like the distributed system here, right? Could be a content delivery network or cdn. Right? Because those are, you know, they're. They're global, right? They're distributed. You can get them from a bunch of different. Like you can get your resources, your assets from, from a bunch of different nodes on the cdn. However, the CDN is usually, I mean, owned and maintained and operated by a single corporation. Right? And so, you know, they have the ultimate say as to what happens with your content, and they could just like remove it. So it's distributed, but we would not call it decentralized.

00:04:05 - Anthony Campolo

Exactly. Yeah. And this is why you'll hear people constantly argue about this in the Web3 space, about how decentralized something is. Is it actually decentralized? And should you use a centralized service for Web3, or does that kind of defeat the whole purpose? Because I work for a company called QuickNode, and QuickNode is a blockchain infrastructure company. And for that, some people will be like, well, why would you use a blockchain infrastructure company? The whole point is to have this decentralized kind of system. And the answer to that is like, well, do you know how to run a Linux server? Maybe, maybe not. And if you want to kind of interact with this technology, there's ways where you can leverage centralized services while still keeping the benefits of decentralization. Because most of these services, all they're really doing is they're just giving you access to this system in a way where if you wanted to move off of them and actually run your own server, you can do that. Because they're not doing anything necessarily proprietary. They're just making a really, really nice, simple onboarding experience into actually interacting with this stuff.

00:05:07 - Ben Myers

Gotcha. Okay. And then I guess. So how does the interplanetary file system fit into all of this?

00:05:16 - Anthony Campolo

Yeah, and this is why I felt that this would be a good topic to pitch to you. And we've talked about how I try to push you out of your bounds a little bit, because this isn't a cryptocurrency. It's not even a blockchain, really, what we're looking at here. It's something else entirely. And I found that it actually can be kind of easy to describe to people depending on their experience. If you've ever used torrents in the past, what's your torrenting experience like, Ben?

00:05:43 - Ben Myers

Limited but non-zero.

00:05:46 - Anthony Campolo

Okay, cool. Yeah, great. So a torrent is a system where you have, say, a bunch of people have a movie on their computer that they want to share with others and the movie company does not want them to do that though. So if they were to put that movie on a centralized server somewhere, then the company that owns the rights that movie can say, hey, I own this movie. You don't. You guys shut this computer down. But if that movie is broken apart and distributed across 10 different systems, they can't send cease and desist letters to all 10 of those, have them all shut down. Especially if one of those computers happens to be in Russia, say so the Pirate Bay and torrents and things like that is an original peer to peer decentralized system that predates all of this stuff. But what if we wanted to use that kind of tech for something, I want to say, like more useful, but something a little more practical, let's say

00:06:40 - Ben Myers

something that doesn't necessarily skirt the bounds of the law.

00:06:44 - Anthony Campolo

Yeah, exactly. And so there's a programmer, Juan Benet, who built IPFS, and there's now a company called Protocol Labs that's heavily based on Bell Labs that is kind of supporting the work behind this. And he wanted to create a distributed peer-to-peer system, kind of like torrents, but instead of for movies, for Git, a distributed version control system. And then that would allow people to have content be decentralized in a way where the content couldn't be taken down. The content could be easily accessible from multiple different places. So that's kind of the origin of, like, what is IPFS?

00:07:28 - Ben Myers

Okay, so we're talking about like, I guess the fusion here, right? Is like GitHub meets, you know, BitTorrent. Right. Is like, you know, because GitHub being a centralized place to store your git repos Right, like that it puts a pretty UI on it. But that's the real utility is that, like, it's a centralized place to host your. Your repos. Right. But this is saying, like, no, we'll actually have it spread out across all the different nodes on the network, all the computers that are participating. And yeah, so it's not like GitHub owns the code. Right. GitHub is the sole arbiter of what happens to the code.

00:08:12 - Anthony Campolo

This is kind of funny, actually, because GitHub is a centralized version of Git, but Git itself was. Was already kind of like a decentralized, distributed kind of thing, because you would have multiple people with these Git repos on their computer. So if anyone ever was on a computer and they just like lost everything, there is probably five other people with that same Git history and so they can get the repo again. Now, this is taking the idea to its logical extreme, which is not only do we distribute it across multiple computers, we distribute across multiple computers, are actually connected to a computer network. That's the really big difference between, like, some people, like, well, Git was already decentralized. I was like, well, yeah, it was decentralized across a bunch of computers that only individual people had access to. So what if we distributed across a bunch of computers and then took those computers and hooked them up to DNS or hooked them up to some sort of protocol that would allow people to then view these through the Internet.

00:09:08 - Ben Myers

Gotcha. Okay, cool. I'm sure I will have more questions as time goes on, but let me go ahead and start sharing my screen and let me actually go. Where's my browser? There's my browser. Hello. All right, so y'all, today we're talking with Anthony. Go follow Anthony on Twitter. Today we're talking IPFS. We went through ahead of time and installed IPFS both for the command line and for their GUI app that they've got. Anthony's put the links to those in the chat. I'm also going to send a link to your First Look at IPFS article that was super helpful.

00:09:55 - Anthony Campolo

Yeah, I should mention this was probably the longest time I've ever spent writing a blog article. Was writing this one because when I first started doing this, like, I had no idea what any of this stuff was or how any of this stuff works. And it was like, really, really confusing to have to figure out. And the docs are actually, they have good docs and the whole system is like set up to be fairly ergonomic in terms of like dev experience type stuff, but just like the mental model of like what was even going on when I was doing it was like so, so weird. But it was literally, it was the first time since I've gotten into web development where I felt like I was doing something genuinely new. Like genuinely like I was doing something I'd never done before. And it was like really, really mind bending. And it took me like a long time to kind of put into a sequence I felt like made sense and that like other people could kind of follow and then ends up being so, so long that I then like had a whole bunch of content for like a whole second article.

00:10:51 - Anthony Campolo

So there'll be a kind of follow-up to this at some point where we get into the entire set of IPFS services that go along with this. Because we're not going to get into, like, we probably won't get into things like pinning services or hosting services for this, because we're just going to show everything you can kind of do from your own computer. But yeah, as you're kind of scrolling, we're eventually going to get to creating HTML files and stuff like that.

00:11:13 - Ben Myers

Yeah. So one question I actually have before we get into this, I guess the question is: are there sites that you feel like you would not be able to deploy to IPFS? And similarly, are there sites that IPFS enables that you wouldn't be able to create without that architecture? Like, do our sites look any differently because they're on IPFS? One thing I can imagine is, like, probably managing your environment secrets, your environment details, is something that's probably a bit of a different story, because you don't really want to be sending your secrets out to a bunch of different computers.

00:12:02 - Anthony Campolo

Yeah, right. And there are ways to manage permissions and controls and API keys and all that kind of stuff. Because even though it is a distributed network, you have a node that is a member of that network, and you can choose what to do with that node. So that node can hide things from the rest of the network if you want, or that node can expose things to the whole network if you want. So this isn't saying that everything needs to be public and that you're just, like, putting all this to this giant network and have no control over what you're putting onto that network. That's not the case at all. But it's set up in a way where if you want to have things be available on all of the nodes so that it's backed up and safe and all that, then you can do that. In terms of the question of, like, what is this for, what is it not for, it is right now being aimed at being, literally as it says on the tin, what we said IPFS stands for: Interplanetary File System.

00:13:05 - Anthony Campolo

So it's a file system, it's a place to put your files. That's really how you should think about it. And that can be music, movies, anything like that. For us, we're going to be focusing on how do you put HTML files onto it? Because once you have an HTML file onto it, then you can just think about like it's a web server and you're exposing that to the Internet. So anything that you can do in HTML and CSS and JavaScript, you'll be able to do in this. I would say for today, right now, I would absolutely not put important mission critical applications that like customers will be using, because the network itself is still figuring out exactly how to be always reliable and up and stuff like that. So like the network, it doesn't really go down, but what happens is you have these gateways that give you access to the network and there's lots of different gateways that are being run by different companies. Like even Cloudflare has a gateway and there's various levels of quality and uptime that go along with all of these gateways. So, you know, this is something where I have always been interested in like kind of new up and coming tech.

00:14:13 - Anthony Campolo

And it's like, I'll play around with it, I'll show it to people. Like, as I've done this more and more, I've become like more and more conscious like always, always saying this is like a newer thing. This is not something that you should like completely rely on. Like it's like super, super established tech. IPFS is five years beyond anything else I've ever talked about. So I'm talking about these things being like new and cutting edge and not production ready. This thing is the farthest from being production ready of anything I've ever promoted. So like, let me be very, very clear about that. This is cool, fun tech you should play around with and you should learn about because it's going to expand your mind and give you a taste of like what's to come. But this is not something you should really, really build a company on unless you feel comfortable becoming an expert on this.

00:14:51 - Ben Myers

Sure, yeah, yeah. Because, yeah, you'll be paying the cost of, you know, the APIs changing or the approaches, the protocols changing, and even just paying the cost of not yet having best practices. Right. Like when, when you're the tip of the arrow, you're, you're going to. Or tip of the spear, I think is the saying. Right. Like you, you're, you're going to encounter all of the pain points, so you're not necessarily going to overcome them the best possible way because no one knows how quite yet. That's. Yeah.

00:15:24 - Anthony Campolo

And that was in the... But the one killer feature that I would say today, right now, if you're thinking about this and what does make it different from anything else, is the idea of permanence. Because think about just the problem of link rot. Like, link rot is such a huge problem on the Internet because people will put up these websites and then maybe they'll change their URL or they'll go to a different hosting service. So if they change their domain entirely, then you have all these links that are out in the world that no longer work, but the content may still be there, it's just somewhere else. Or you may have something where there was some content that was really, really important that you wanted to save, but then someone changed it. And so the link is the same, but the content is different. Like, all of that stuff makes it almost impossible to use the Internet as a historical source, unless you're doing something like the Internet Archive, where they're constantly taking snapshots and uploading them. So I would be very, very surprised if the Internet Archive does not at some point move to some kind of tech like this, because I think it really makes a lot of sense in a lot of ways.

00:16:22 - Ben Myers

But on the other token, that permanence seems like it could be something that's ripe for abuse, because, you know, I could put, like, doxing details out there, right? And it's a lot harder to have that wiped, I guess.

00:16:37 - Anthony Campolo

Yeah, that's, and that's one of the biggest concerns with this tech, for sure, and it's going to be, I think, up to the gateways to kind of manage that. Because if something is on the network, if something's on IPFS, but the Internet gateway wants to block it, then they can do that because the gateways still have control over the traffic that's going in and out and all that kind of stuff. So if you want to kind of set this up in a way where it's a little more friendly to stuff like that, you're going to want to kind of stick with things like Cloudflare, because then you're still going to be going through these more centralized services. And this is a problem, it's like the problem of freedom itself. The problem of freedom means that people are free to do bad things sometimes. So that's a real concern, and it's one that I need to kind of learn more about and how that's going to be mitigated by systems like this. I think for us, like, I just want to show it to web developers who are interested in this kind of stuff.

00:17:39 - Anthony Campolo

And I would say that if you're kind of worried about like having your content, like docs and stuff like that, like people in like my, my general advice is that like be wary of what you put on the Internet, you know, and if you're always careful about what you put on the Internet, then you'll be less likely to be doxed. But otherwise it's like you, you got to find people you can trust that you share stuff with on the Internet and this is a huge societal wide problem that we're all going to have to kind of come to terms with at a certain point. And unfortunately I don't have a ton of great answers for.

00:18:14 - Ben Myers

Yeah, and I think the caveat I've got is that like, even, even if you do like limit who you're trusting people with information on, right. Like, you know, you can still, you could, you could be the subject of a cyber attack or you could be like the subject of a revenge porn attack or something like that. Like someone who was unauthorized or someone you once upon a time trusted can like still put content out on the web that like you. Yeah, like, like you should, you should not be held responsible for that kind of stuff, I feel. And like anytime you talk about like permanence as like enshrining a thing on like a blockchain or you know, a distributed network or something like that. Right. Like these are things that you have to deal with is like, even when people are being their like their best, right. And not doing anything, you could fault them for like there are still going to be malicious actors who like will take advantage of systems like that to abuse them and do terrible things. Right. And I'm of the mindset that like an infrastructure and architecture like this absolutely needs ways to deal with that.

00:19:28 - Anthony Campolo

Yeah, I would guess that we'll probably find ourselves in a situation where there will be kind of more moderated networks on IPFS, where there'll be nodes that will get together and collectively decide what's appropriate content and what's not, and then they'll kind of police that. And then people who want to just do whatever they want will go on to the more kind of wild west networks. If I had to put my prediction hat on, that would be where I think this is going to go. But it's hard to say at this point.

00:19:56 - Ben Myers

What that does sound like to me is the solution is centralization.

00:20:01 - Anthony Campolo

Which is it would be centralization though, because it would require a group of people to collectively decide those moderation rules. That would be the difference. Okay, yeah. Which I think is actually that could be a cool thing, I think, because, you know, not everyone will agree with what needs to be moderated and what doesn't. Sure.

00:20:17 - Ben Myers

All right, I want to get into these.

00:20:18 - Anthony Campolo

These are the type of cool, fun problems that come up when you start trying Web3 stuff. You get these huge philosophical questions very quickly.

00:20:25 - Ben Myers

Absolutely. But I want to actually look in and do some writing, some code, getting some stuff deployed. So how should we get started?

00:20:34 - Anthony Campolo

Yeah, so the first thing is let's go to our command line and since you already have the cli, let's just do the IPFS version.

00:20:45 - Ben Myers

Cool.

00:20:45 - Anthony Campolo

So we're on 0.13.1. So we're already past my blog post which was written on 0.12.0. And this is a repository that now is on your computer. Because as I was saying, this is just git. You have a git repo and so type IPFS init. You may have already done this, but just if anyone's following along, this is the first step they need to do. So this is going to initialize their repository. And you also see there you have a peer identity. So the peer identity is when you actually connect to the network. Then you're going to be able to kind of find someone else on the network through their peer identity.

00:21:26 - Ben Myers

Gotcha. So this what just got logged here, this is not sensitive in any way. Right. I don't need to have blurred this out or anything like that. Okay. It actually seems like my config file already exists. Interesting.

00:21:40 - Anthony Campolo

Yep. Yeah. And then you also see how it says reinitialize when overwrite your keys. So this is why I say this is a locked down system. This is something with keys that only you have access to now, right now on your computer. So those keys are important and like, they have set the system in a way where they're on your computer somewhere and I'm sure you could find them if you, if you want to. Like, I wouldn't even really know where to go to find them. So there's kind of more education that I think needs to happen around, like, what is actually public and private here and what is lockdown and what's not. And for right now, we're just kind of going to be doing like simple HTML exercises. So it's not going to be like a huge deal, but like, there's larger questions, like, how is this system actually secured that are worth going into if that's something you find interesting.

00:22:28 - Ben Myers

Gotcha. All right.

00:22:31 - Anthony Campolo

Okay. So now when you first initialized it, you can't see it here. It will usually give you the ability to kind of log the first. Let me drop this in the chat. So when you initialize, the first thing they do is they say, hey, run this command here.

00:22:54 - Ben Myers

And.

00:22:55 - Anthony Campolo

And what's going on? What's going on here is there's a content hash. So content hash is the first thing you really gotta understand about how does IPFS work? Because first off, what's a hash? Ben?

00:23:15 - Ben Myers

Right. Yeah. So whenever you. I'm trying to think of the best way to explain it. Basically it's a way to verify that some content is what you say it is by basically performing a lot of transformations on the content. And those transformations are lossy, you can't reverse engineer them. But the same, like, like, like at the end of that process, you get a seemingly more or less random string that, like, if you had made even one tiny change to the content that you had asked, you would have had a wildly different string at the end. So it becomes fairly straightforward to just compare some very small, lightweight strings and trust that it's like, good enough. Now, multiple things can usually resolve to the same hash, but those things are usually so disparate, different enough that like, you know, you wouldn't be, you know, like, you wouldn't expect, like, anyone to get those things confused. Right. So if you end up with a hash and it's the same hash as what you told me to expect, then, like, I know that, roughly speaking, this stuff hasn't been tampered with or changed in any way. I think you've gone on mute.

00:24:36 - Anthony Campolo

Yeah, sorry, drinking some water. Yeah, yeah, that was all correct and all good. And the important bit in there was: when you do the hash, the thing that the hash spits out is globally unique, like it will not ever be created again. And so this is what makes it useful for this permanence idea, is that once you create a hash from your content, that is something that will stay the same forever. And if you change the content, then you get a new hash. And this is something that will be, like, once you get kind of further down the line of using this stuff, like wait, how do I update my website? What you can do is you can have that hash point to another hash, and then that hash can stay the same while you update the content. That's something that we may get to, may not, see how far we get in this. But let's actually, real quick, because I always forget at what point of the process this actually becomes important or not, let's just open up another terminal and get this going. For now, we're going to start the IPFS daemon.

00:25:41 - Ben Myers

Okay. I think that's already been started thanks to me opening up IPFS Desktop earlier. Okay, well, it says it's initializing. Okay, cool.

00:25:51 - Anthony Campolo

Let's see.

00:25:53 - Ben Myers

Are we expecting more? Oh, there it is. There it all is.

00:25:56 - Anthony Campolo

Yeah. So now this is us actually connecting to the network. And yeah, I'm not sure if IPFS Desktop does this automatically, but this is a good thing to do regardless. And you see all these, we have IP4, IP6, TCP, UDP. You see all that stuff? This is where we're actually connecting to the Internet now. And our kind of IPFS node now is going to be able to take the content that we're creating, we're putting on our own node, and expose that to the overall network. So hopefully things will work and people can actually view these websites. We'll see if that actually happens or not. But let's go back to our other terminal now, right? Yeah. And then could you just grab that thing I dropped in the chat and run that command? Because usually it pops up the first time you initialize.

00:26:44 - Ben Myers

Yeah, is that. Okay, cool.

00:26:48 - Anthony Campolo

Yeah, that runs the CAT command, which basically just reads the file out to the terminal. And this is pretty cool. I like this little hello world experience here. They're saying, "If you're seeing this, you are now interfacing with the IPFS Merkle DAG," which is a distributed acyclic graph using Merkle trees. So that's all crypto stuff you don't gotta worry about too much. But it's showing you that you have a couple different files here. And if you noticed when we did that CAT command, you have the long content hash, then you have the readme after. So what's happening here is directories have content hashes and files have content hashes. So if you use the directory content hash, then you can view other things inside that directory. So do that exact same command, but change to, let's do security notes. Let's see what this is. Yeah, there you go. So "we try hard to assure your system is safe and robust." So they're letting you know this is alpha software, letting you know that it's a networked program. You always got to worry about things like that. And then they also say, hey, we have a security team here, so if you ever need help, contact us.

00:28:12 - Anthony Campolo

And then it's not necessarily proven secure yet, which basically just means there are always going to be security vulnerabilities that may exist depending on what kind of encryption you're using. But these are people who are like academic researchers. So if you want to put your trust in, like anybody is like you as the buck's got to stop somewhere. And so like, these are people who actually know how cryptography works, know how encryption works. So this is a relatively, I think, somewhat safe system at this point as like crazy new alpha software kind of goes. But just like disclaimer, as we've been kind of giving disclaimers as you can go, this whole thing, this is something new. This is something that you should not like, really, really put super duper important sense to stuff on.

00:28:56 - Ben Myers

Absolutely. It's definitely a use at your own risk. Disclaimer.

00:29:00 - Anthony Campolo

Yeah. Cool. And then do that same thing again, but go to the about page.

00:29:04 - Ben Myers

Got it.

00:29:08 - Anthony Campolo

Okay.

00:29:09 - Ben Myers

Oh, look. Wow. It's got a whole thing.

00:29:13 - Anthony Campolo

Yeah. And this is a lot of the stuff that I talk about in my blog post. I think "IPFS is a web" is a really important one, which is that it can be used to view documents like the web and that they can then be accessed through HTTP. So let's actually, let me try that real quick. So if we take the thing that I posted in the chat and you go to... [unclear].

00:29:50 - Ben Myers

Where are we going?

00:29:51 - Anthony Campolo

Sorry. So I'm trying to do a couple things at once right now. All right, go back to the terminal you just had up real quick. And then scroll up a little bit to where it says "a web." Yeah, so take where it says HTTP IPFSIO and then path. Yeah, so grab that and then paste that in. And then paste everything from IPFS forward slash on from the Twitch command. So basically it'll have IPFS forward slash the content hash. All right, so this whole thing. Yeah, let's see if that works.

00:30:36 - Ben Myers

Okay. Yeah, it's the same. Same file.

00:30:40 - Anthony Campolo

Great. So anyone else should be able to go view this as well. And this is where all the important stuff kind of starts coming together, because this is where this becomes an actual website on the Internet other people can look at. So how is this possible? This is possible because of IPFS IO. That is the gateway that I was referring to earlier. So that is one that Protocol Labs themselves are running. They are managing that gateway. They are ensuring that that gateway stays up and stays reliable and available. There's also other ones, like Cloudflare. So Cloudflare has an IPFS gateway. Let me grab a link for that. So that's going to be basically the same thing, but instead of IPFS IO, it's going to start with cloudflare-ipfs.com.

00:31:34 - Ben Myers

And then it's still /ipfs/Qm..., etc.

00:31:39 - Anthony Campolo

Yeah, exactly. This is the point where things start to really click together for me, because I was like, oh, okay. So the content hash is something that always stays the same, and so you can reliably expect it to always stay the same. And then you have these gateways which are different ways to access it, but the gateways are just giving you access to the content hashes. So the gateways can change and you have different gateways, but the content will always stay the same. And then the content can. Once you figure out where the gateways are, then as the content is changing, you keep the same gateway, you change the content, then you see all the different stuff on there. So like, oh, wow, this is actually really, really cool.

00:32:13 - Ben Myers

Absolutely. Okay, cool.

00:32:15 - Anthony Campolo

All right, so let's now start making our own stuff. Yes, now we all see all that. What we should do next is create a directory with some stuff in it.

00:32:31 - Ben Myers

All right, I'm just going to call this semantics ipfs.

00:32:35 - Anthony Campolo

Yeah.

00:32:36 - Ben Myers

All right, we'll go in there. All right.

00:32:44 - Anthony Campolo

You can just create an index HTML file and then put your standard HTML boilerplate and you can say whatever you want in there. Say hello, put some links or anything like that.

00:32:57 - Ben Myers

Right.

00:32:57 - Anthony Campolo

Be curious, when you first start, like a completely skeleton HTML page, are there any specific things you do to ensure that it's accessible? Or do you just try and stick

00:33:08 - Ben Myers

I use... weird, a VS Code profile seems to have opened up for me. That's unusual.

00:33:18 - Anthony Campolo

You want to check that out real quick?

00:33:23 - Ben Myers

Fine. I just, yeah, I'm missing my snippet that I've usually got for this. Does this have any of my extensions or anything? You know, I just restarted my computer. I wonder if VS Code did an update or something like that. Interesting. Oh my God. My cat is trying to barge in.

00:33:43 - Anthony Campolo

Is there somewhere online where you had. Where you got that snippet from?

00:33:48 - Ben Myers

It was the like, Emmett exclamation mark. You know what I'm going to do? I think, I think that the reason this is weird is I haven't actually opened up a directory. So let me try this once more. I'm gonna open up this current directory, then I think we'll be good. Yeah.

00:34:10 - Anthony Campolo

VS Code, where we'd have issues.

00:34:13 - Ben Myers

Yeah, yeah, no, so far all the IPFS stuff is working great. It's VS Code that's the problem today. But yes, I use, like, there's a fairly standard exclamation mark. Here we go. Yeah, this is looking more like it.

00:34:31 - Anthony Campolo

Yeah, I saw it all the time in, like, you know, Brad Traversy's videos, and when I was first learning they would always do that.

00:34:38 - Ben Myers

Yeah, all this index.html we will update later and not update on stream. Updating things on a stream is a bad idea. Okay, this should hopefully do it. Okay, well, I don't know why that isn't going, but that's fine.

00:35:06 - Anthony Campolo

All right.

00:35:07 - Ben Myers

But yeah, so you're going to have your HTML tag. This I think needs a. We need doctype HTML up here.

00:35:16 - Anthony Campolo

So Nocturne is asking, what are some of our favorite VS Code extensions? I try and keep mine pretty light for the most part. The biggest one for me that I think everyone should use and install automatically is Import Cost. What Import Cost does is it shows you the exact number of kilobytes of all of your dependencies whenever you're adding them to one of your projects. And if you're someone who does a lot of JavaScript-y stuff, you'll quickly realize why everyone's been telling you not to worry about how much JavaScript you're putting into your projects.

00:35:53 - Ben Myers

All right. Yeah, here we are. We got our snippet going. The main things: your HTML element needs a lang attribute. We've got UTF-8 encoding. We've got the viewport width set to the device width. This is so people can zoom in without things getting weird. And then I like to add a main tag. I'll say "Hello, world." Then just for the sake of expediency, I'll drop in some lorem ipsum there.

00:36:34 - Anthony Campolo

Yeah.

00:36:34 - Ben Myers

Okay, cool. So this is a boring page, but yeah, Nocturne, I will have to look through my extensions. Let me just pop this open. Mainly, I have a whole lot of themes and stuff like that. I have a Browser Sync one that lets me run any web page as a local web server just through the VS Code interface. That stuff's good. Yeah, quickly going through, most of these are themes. I also just love anything that provides reusable snippets out of the box. Okay, so we've got us some content. It's, you know, it's not pretty. Oh, you know what I actually have. There we go. We're pulling in.

00:37:25 - Anthony Campolo

Oh, you should give us a meta description as well.

00:37:30 - Ben Myers

Oh, do we want to use a meta description? We totally can. Yeah. What is it? It's like meta. There we go. This was deployed IPFS on stream on a semantic stream.

00:37:49 - Anthony Campolo

There we go.

00:37:53 - Ben Myers

Cool. So, yeah, we've got that now. We could add a whole lot more, but for the sake of expediency, I think this is, this is what we'll probably be good with for now.

00:38:06 - Anthony Campolo

Great. Okay, now we have our website. Let's go back into our terminal.

00:38:13 - Ben Myers

All right.

00:38:13 - Anthony Campolo

And in the one where you're actually in the project, go one level back out so you're no longer inside of it. And then now what we're going to do is run IPFS add. And so this is the command that's going to actually put this onto your node. And before that, you're going to do a dash-R flag.

00:38:34 - Ben Myers

Okay, Is this recursive? So it adds the whole directory structure.

00:38:40 - Anthony Campolo

God, you're so smart, Ben. That's exactly what it is. When I first saw, I was like, why is it recursive? What does that mean?

00:38:53 - Ben Myers

Yeah, if we had folders within folders within folders, all of those would get added rather than the top level.

00:38:59 - Anthony Campolo

Yeah, so that should be it. So go ahead and run that command. If all went according to plan, we will now have two content hashes here. So Q, drop both of those in to the chat.

00:39:13 - Ben Myers

Yeah, I'm just going to. It's not going to be pretty, but I will just highlight this whole thing.

00:39:22 - Anthony Campolo

All right, let me start messing around with these a little bit. So do the. Let's see, which one should we do first? Do the cat command that we were doing before. So just go up through your old. Your old.

00:39:36 - Ben Myers

Yes.

00:39:37 - Anthony Campolo

Yeah, go up.

00:39:38 - Ben Myers

Here it is.

00:39:39 - Anthony Campolo

Yeah, take that One. And then. Yeah. Grab that whole thing with the index HTML at the end.

00:39:45 - Ben Myers

Okay. So actually.

00:39:47 - Anthony Campolo

So it'll be. So it'll be the bottom one, actually, because you want to do the directory hash. Yeah. And then we'll. We'll try both of these and then people can see.

00:39:57 - Ben Myers

So I nuke this whole hash. Right. Because this. This is not my project. There we go. And then it's going to be index HTML.

00:40:06 - Anthony Campolo

Yep. That should just show you the content.

00:40:09 - Ben Myers

Do I need semantics IPFS?

00:40:11 - Anthony Campolo

No, I don't think so.

00:40:13 - Ben Myers

Okay. Yeah. Cool. Here we are. So. And then now it's of our HTML file.

00:40:17 - Anthony Campolo

Yeah. And then now do that command again, but with just the content hash of index HTML and without anything after the content up here. Yeah.

00:40:28 - Ben Myers

Okay. Type this out. Got it. And that's my HTML file again.

00:40:39 - Anthony Campolo

Yeah. Now let's try doing that with the IPFS gateway and see what comes up.

00:40:45 - Ben Myers

By that you mean going back into our browser?

00:40:49 - Anthony Campolo

Yeah.

00:40:49 - Ben Myers

Okay, so we take. This is the hash for just the HTML file.

00:40:58 - Anthony Campolo

And this is probably. This is the point where something is almost certain to go wrong, because a lot of times I'll do this, and then for some reason, the content just doesn't show up. And it might be because it takes a while for it to propagate.

00:41:09 - Ben Myers

This is also the cloudflare gateway. So if you'd like, I can go to, like, IPFS IO and set.

00:41:15 - Anthony Campolo

If you'd like, let's start with that one and see what happens.

00:41:20 - Ben Myers

Okay, well, it's thinking, do I need to do the directory one instead? Would that be better trying both of

00:41:28 - Anthony Campolo

them right now and seeing what happens? Let's hold off on this for a second. Let's pin it, and then that might help out. So pinning is an important part. So when you talk about IPFS being permanent, and when you put something on there, it's on there forever. There's a massive, massive asterisk next to that claim, which is that if you don't pin the content, then it will regularly. Your content regularly gets garbage collected off of the network. And this, it does make sense because if you think about, like, if every time everyone put anything on the network, it stays there forever, the network's gonna just explode in size in, like, no time. So it's set up in a way where you can put something on your node and then it'll be on the network, but it's not really there permanently yet. To actually make it permanent, you have to pin it. And the pinning part is there's stuff I can get Kind of complicated about. There's actually entire services now based around handling how you pin your IPFS content. Okay. But for. For now, let's go. Let's grab the. The hash. The. Grab the first hash that your.

00:42:32 - Anthony Campolo

Your terminal spit out for you.

00:42:35 - Ben Myers

That's. That's this one. The. Okay, so I've got that.

00:42:44 - Anthony Campolo

And then do IPFS PIN add and then that.

00:42:50 - Ben Myers

Okay. IPFS PIN add and then our hash. Like that?

00:42:55 - Anthony Campolo

Yeah, just like that. Okay, great. And now do IPFS PIN ls. Is that dash LS? [unclear]. No, just ls.

00:43:08 - Ben Myers

Okay.

00:43:09 - Anthony Campolo

Okay, cool. So that's the stuff that we have pinned right now. So if you see the very last one, it has you. You pinned recursively. So let's go into. Yeah, now let's go into our IPFS desktop application.

00:43:25 - Ben Myers

You got it. We've installed that ahead of time. Oh, that's just the installer. Okay, let me just use the Spotlight search. It's sinking it secretly behind here. Is this your card?

00:43:55 - Anthony Campolo

Yes. All right, cool. So this is. So you see, we're connected and you can see bandwidth and metrics and stuff like that. And go to files on the left.

00:44:14 - Ben Myers

The fun fact, clicking files doesn't necessarily take you to files immediately.

00:44:19 - Anthony Campolo

Yeah. Imagine it's just lagging because of the stream. All right, so this. Right now, we don't see anything. So click import on the top right.

00:44:29 - Ben Myers

Okay.

00:44:30 - Anthony Campolo

And go. Let's do it from ipfs. And then do the. The path for your. The content. So it'll be just forward slash, ipfs forward slash that.

00:44:45 - Ben Myers

Okay, if this. Okay.

00:44:47 - Anthony Campolo

Like this and then just like that. Yeah.

00:44:51 - Ben Myers

Do we name it or not?

00:44:53 - Anthony Campolo

Sure. Yeah. Okay, cool. And then click it. And you see how it has pinned status next to it. So that shows that it's been pinned.

00:45:09 - Ben Myers

Yeah. So if I go back here. Okay, it is pinned. All right.

00:45:12 - Anthony Campolo

Yep. And then go to more. And then let's go share link. Let's see what happens with that. Copy that, Copy that.

00:45:24 - Ben Myers

Put it in the Twitch chat as well for folks at home. Then let's go open this. Oh, hello. All right. Yeah. So opening this up. Nice. Okay. Yeah, we do have our file.

00:45:41 - Anthony Campolo

We're there.

00:45:41 - Ben Myers

Yeah, we deployed. We deployed. We can go ahead and end the stream here.

00:45:45 - Anthony Campolo

You know, Hey, I was hoping we would actually get to this point. This is where I was hoping we would get to. That's awesome.

00:45:55 - Ben Myers

And to confirm, if you open up that link on your end, you're seeing this as well. We are officially deployed and pinned. Our site is going to live here more or less forever.

00:46:07 - Anthony Campolo

Right, that's the idea.

00:46:11 - Ben Myers

Okay.

00:46:11 - Anthony Campolo

Trying to actually come up on my computer. This is where stuff always gets a little wonky, and why I would usually recommend: if you actually want to put a website up on IPFS, you should take a look at something like Fleek. Actually, we have 15 minutes. I wonder if we can get this up on Fleek.

00:46:31 - Ben Myers

That what you want to do?

00:46:32 - Anthony Campolo

Let's do it. Yeah, create a Fleek account really fast. Should be fleek dot... hold on.

00:46:39 - Ben Myers

Fleek. Am I hearing that right?

00:46:41 - Anthony Campolo

Fleek. Yeah, Fleek co. That's the one.

00:46:44 - Ben Myers

Okay,

00:46:49 - Anthony Campolo

So what this is, Fleek is, because, you know, why wouldn't we have this? It's a Jamstack hosting provider for IPFS.

00:46:57 - Ben Myers

All right.

00:46:59 - Anthony Campolo

And by the way, I was able to get to the site and I'm not seeing it on my. I am seeing it on my computer.

00:47:04 - Ben Myers

Should I go with git provider for email? I don't have Ethereum.

00:47:09 - Anthony Campolo

Do Git provider. Yeah.

00:47:11 - Ben Myers

Cool. It allows GitHub. Awesome.

00:47:16 - Anthony Campolo

You should get your index up on your semantics. GitHub or whichever GitHub you're going to connect here.

00:47:24 - Ben Myers

Yes, let's go ahead and do that real quick. Oh wow. There we go. Okay. Yeah, git init, git commit, add everything, add a message, index.html. Oh really? Okay, add. There we go. There we go. We'll create GitHub repo antics-dev-ipfs-public. Yes. Push it up. And if anyone wants to see our incredibly thorough repo, it's there. Okay, cool. Yeah. So now... oh, okay. Oh, did it get me all signed in? I don't think I ever... okay. Yeah, I don't think I ever actually finished clicking.

00:48:34 - Anthony Campolo

Okay, so add new site.

00:48:37 - Ben Myers

Add new site. Connect with GitHub. Okay. It's going to make me actually do this. All right. And I want this in.

00:48:48 - Anthony Campolo

Yeah, this will probably let you give access to just the individual repo, which is always good. So only select repositories.

00:48:55 - Ben Myers

Yeah, we're just going to select minimum permissions.

00:49:01 - Anthony Campolo

Always.

00:49:01 - Ben Myers

Yep. That. All right. Oh boy. Let me real quickly go into privacy

00:49:14 - Anthony Campolo

mode and then if people have questions in the chat, now would be a good time to start dropping those. Hey, works on mobile. Nice.

00:49:23 - Ben Myers

Yep. I have to open up another browser so I can get my LastPass instance up. I think. Yeah, we are in privacy mode. Awesome. Okay, so in the meantime, what is Fleek? Like you said, this is a Jamstack provider for IPFS.

00:49:42 - Anthony Campolo

Yeah. So as I was saying, there's going to be a lot of higher-level concerns when it comes to using this, which is making sure that's actually pinned, and then making sure that when you try and update your website, you don't have to also update the content hash every single time. So there's ways to do this with IPNS, the Interplanetary Name System, which is like a DNS for this. Because think about it, we're essentially trying to rebuild the entire Internet with this thing. So you can't necessarily use DNS directly. What you can do, though, is create your own name on IPFS, and then that will point to a content hash. And then you have a DNS record, a DNS text record, that points to your IPNS name, which points to the content hash. So there's ways to do it so a regular old HTTPS request can find that content hash. But there's a lot of steps in that chain. There's a lot of knowledge about DNS and the architecture of the Internet. And this is what I was saying, this thing just blew my mind.

00:50:44 - Anthony Campolo

I had to think about DNS for the first time ever. I had to figure out that DNS can actually just point arbitrarily to anything you want. And so you just point it to like this other thing and then it'll just kind of go down the chain. And that is what is going to be stuff that you don't really want to have to do yourself and would be nice to just offload to a service. And also we want a service that's also going to let us to get to a git repo and every time we get changed, push the change. That's what we expect. Now anything less will be beneath us.

00:51:14 - Ben Myers

Gotcha.

00:51:16 - Anthony Campolo

Because Netlify has spoiled us all. Netlify raised the standard of what we expect a system to do for us.

00:51:25 - Ben Myers

Okay, let me get the actual correct password in there and then let me

00:51:29 - Anthony Campolo

get

00:51:32 - Ben Myers

[unclear] with GitHub Mobile. Oh no, it isn't. Okay, cool, we're good. In that case, let me turn off privacy mode. Let me confirm our friends at home can now see what we're seeing, which is a big authorized button.

00:51:49 - Anthony Campolo

Yeah.

00:51:50 - Ben Myers

All right, cool, with that, finally we'll choose that one. Then should I go ahead and choose IPFS?

00:52:02 - Anthony Campolo

Yeah, cool.

00:52:04 - Ben Myers

[unclear] this a bit. I could choose what branch to deploy off of. I currently only have the main branch. Anything else?

00:52:18 - Anthony Campolo

This is hot. New framework HTML, it's so underground no

00:52:24 - Ben Myers

one's working with it yet.

00:52:25 - Anthony Campolo

Yeah, I think you can just hit deploy site. I think that's all you got to do hopefully it should know what to do.

00:52:33 - Ben Myers

This is really just the Netlify of IPFS.

00:52:37 - Anthony Campolo

It really is, right? This is why I'm trying to talk to people at Netlify, like, hey, you know, you could build this, people would think it's cool, and you'd be the leader in the system immediately. Yeah. So right now, a lot of the older Jamstack providers are not doing anything with IPFS. It's kind of these new upstarts creating imitations of them for IPFS. Cloudflare is really the first kind of big pre-Web3 Internet company that has gone all in on IPFS. They've done a lot of stuff with it. So I'm going to be curious to see when more of these Jamstack providers start to get into this.

00:53:22 - Ben Myers

Looks like we are deployed. I could preview the deploy and it's going to give me a link, stuff like that. This is handling deploying things out and updating pins so that if people are trying to access resources, they can see them.

00:53:42 - Anthony Campolo

Let's go back to your dashboard real quick.

00:53:44 - Ben Myers

Yes.

00:53:46 - Anthony Campolo

And let's take a look at. Go to overview.

00:53:51 - Ben Myers

Overview. Okay. Oh, and it does look like I've got a link up here.

00:53:54 - Anthony Campolo

Okay, so if you see here where we have name, owner, repo, and then the current IPFS hash, and then don't worry about the Filecoin stuff or anything like that. Let's go to settings.

00:54:11 - Ben Myers

Okay.

00:54:15 - Anthony Campolo

And then there should be a way to name your domain.

00:54:19 - Ben Myers

Oh, okay. So I. Instead of it being this round paper 7017 I could call it. Oh man, this really is Netlify for the IPFS.

00:54:39 - Anthony Campolo

Yeah.

00:54:40 - Ben Myers

Okay, so now we've got that. So it looks like my site is semantics-IPFS on fleek.co. Yeah, there it is. So let's go ahead and put that... oh, you've already put it in the chat. Thank you. Okay, so all right, let's say I've been working on this, right? And this site is very feature-complete, but nonetheless I would like to add more features. I have more content I want to add, right? What is the process now for updating my content, or kind of going native IPFS, like how do I broadcast that I've got a new version of the site for people to use?

00:55:26 - Anthony Campolo

I'm fairly certain at this point, if you make a change and you push it to that Git repo, everything else will be handled for you.

00:55:32 - Ben Myers

Well, so on the fleek end. Right, but not on the fleek end.

00:55:35 - Anthony Campolo

Exactly. Which is. And that's why this service is so valuable for you.

00:55:39 - Ben Myers

Yeah. So I'll go ahead and, you know, add in another paragraph tag with another lorem ipsum. Boom. Yeah, boom. Right, so Fleek is already going to take care of this. Cool. Yeah. What kind of stuff is it abstracting away from me for, like, IPFS stuff?

00:56:11 - Anthony Campolo

Yeah, so IPNS, the naming system in particular, I'll drop a link to that in the chat as well. And this is what allows you to not have to constantly update the content hash every time you want to change something. And then it's also kind of guaranteeing that there's a gateway that's going to be fast. And I'm assuming they're also caching their content and making it so it's on a CDN. Because when I first did this exercise, I was trying out different gateways and different ways of viewing the content, and I ended up with a website with like five links to it through different gateways, and then one through Fleek. And there is something called EthLink, which, if you go to the website, nothing will come up because I'm not sure if this thing even works anymore. It's a Cloudflare service that lets you connect to ENS, because there's also the Ethereum Naming System, which lets you have a domain that is an NFT, and then that domain can point to an IPFS content hash, and you can point a DNS record to that domain.

00:57:22 - Anthony Campolo

But there were all these links that I would have to it, and some of them would load slowly, some of them would not load at all, ever. And then Fleek would load fast every single time and would work every single time. So the thing with the centralized-versus-decentralized debate is, if you try and go 100% decentralization-purist, you're going to have stuff just not work very well. And that's because it's going to take five, 10, maybe 20 years before the system becomes really super reliable in that sense. So if you want to play around with this stuff and you want to actually start building websites with it, use something like Fleek. The content is still on IPFS. If you ever want to move off Fleek, you can do that. But it's going to do so much for you and it's going to make your life so much easier that you're going to be able to start interacting with this technology much quicker. You'll be able to start shipping stuff much faster. And I think that the more Web3 people can embrace this hybrid centralized-decentralized model, the quicker we're going to actually start convincing people that this stuff is useful and usable.

00:58:22 - Ben Myers

Gotcha. Okay, and you had quickly mentioned NFTs, and I don't want to make this an NFT stream, we've discussed this ahead of time. But just so I can understand the technology, because I had heard that, for instance, NFTs were effectively just a hyperlink to something in a database, right? It's this hash, right? Like it's just pointing to the hash in IPFS.

00:58:48 - Anthony Campolo

So the NFT itself, that is an identifier that is globally unique and then that identifier is on the blockchain. So that as you say, can point to a database, it can point to just an S3 bucket, but you can also have it point to an IPFS content hash. And so that's where you can feel a little more safe that your NFT is not just going to disappear because it can't just be taken off of a database. And so this is why it's really important if you are going to get into NFTs and you understand where is this NFT actually live? Does it actually live on a decentralized system or is it just on someone's computer somewhere? Because that, that can be really dangerous if you want to pay a bunch of money for something that could just disappear and never be there again. So that's why having an NFT that is actually on IPFS is when people are thinking about how NFTs work. It only really works the way people think it does if it's on a system like this and not just pointing to a database somewhere.

00:59:44 - Ben Myers

We have a good friend of both of us, Michael Chan, in the chat putting it very succinctly, which is, "Yeet my data into space." With that, we are unfortunately coming up on out of time. I want to wrap this up with: what do you think web developers, especially those of us like myself who would consider ourselves squarely Web2, should keep our eyes on going forward? I'm not interested in cryptocurrency, NFT, that's just not my purview. What should people be keeping their eyes on in terms of this kind of work?

01:00:30 - Anthony Campolo

Yeah, I would say keep an eye on the non-Web3 companies. Like, I don't really like the term Web2 and use it as shorthand. I prefer not to create this us-versus-them or future-versus-past narrative. So I say, look at non-Web3 companies that are doing this and see how much buy-in we're getting from them. Because as companies like Cloudflare, maybe Netlify or Vercel, start to get into this, that's where it's going to be easier to bridge this gap for people who don't want to have to go through this whole process of learning an entirely new mental model and system. So if you're someone who's just very practical, like, I just want to build stuff, I want to work, then I would say you don't really have to worry about IPFS for a while. If you're someone who's interested in new tech and you like learning new things, you like kind of having yourself stretched, then this thing right now is at a point where it's stable enough and built out enough and has enough conventions built into it that you can start reliably learning these things and internalizing these mental models.

01:01:28 - Anthony Campolo

And those are going to stay the same: the idea of the content hash, the idea of the gateways, the idea of how this whole thing kind of fits together, that's not going to change. So if you're someone who wants to build expertise in something that's going to be long-lasting and valuable into the future, I think that being an IPFS expert is something that is going to massively pay off down the line. Now the question of when that is, I can't tell you. I can't predict the future. All I can say is that there is a direction that the Internet is going, and this is going to be a big part of it. I feel pretty dang confident that that is the case. Now, that doesn't mean the old Internet is going to go away. The old Internet isn't going to entirely be IPFS. There's going to be some sort of combination of the two, and the two will interact with each other, and at a certain point, to users there will be no difference. They will not have to worry about these gateways at all. At a certain point, people will just write links into their address bar and it'll take them to places, and sometimes it'll take an IPFS link and sometimes it won't, and the users will have no idea.

01:02:24 - Anthony Campolo

But to me, that is the future, I think, where we're headed towards.

01:02:27 - Ben Myers

All right, well, Anthony, thank you so much for your time. I always learn some really cool stuff from you every time you're on, so I really appreciate your time. Y'all go follow Anthony on Twitter. Yeah, let's shout out Alex Trost. That means a lot. We super appreciate having you and all of y'all in the chat. Thank you so much for being here. Chat, stick around. We are going to find someone to raid. But also, if you're not already following Semantics, you should. We've got some exciting streams coming up. One I'm particularly excited about is this Friday with Lindsey Wardell. Back in January, Lindsey came on to teach me the basic Elm syntax, but we weren't able to get very far into making, like, real things. So Lindsey's coming back on this Friday at 2pm Central. We're going to be building Elm apps, so absolutely follow Semantics if you want more streams like this. And follow us on Twitter so you can keep apprised of all the good streams. Alex, thank you so much for gifting that sub. That is too kind.

01:03:40 - Ben Myers

And, yeah, we will see you all around. Bye, y'.

01:03:44 - Anthony Campolo

All right, bye, fam.