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 Some Antics, 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 Some Antics 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 Some Antics, 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 Canthony," web developer himself. Welcome back to the stream, Anthony.

00:00:22 - Anthony Campolo

All right. That's the first time I think I've heard you say Anthony Janthony Canthony out loud. I've only seen you type it so far.

00:00:28 - Ben Myers

I mean, what else could AJC stand for, honestly?

00:00:33 - Anthony Campolo

Nothing. 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 Some Antics 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 Some Antics stream. Thanks to you, we've done streams on Vite and on Deno and stuff like that, things I wouldn't usually consider within the Some Antics 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 past streams in the chat. 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, 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 the Interplanetary File System. So I guess let's kind of talk about that. 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 it means 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. I actually first got into this stuff before I really knew how to code at all. I've been very interested in Web3. I actually wrote 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 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 a single central actor that is 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 if you think about it...

00:03:29 - Ben Myers

An example of the distributed system here, right, could be a content delivery network, or CDN, right? Because those are global. They're distributed. You can get your resources, your assets, from a bunch of different nodes on the CDN. However, the CDN is usually owned and maintained and operated by a single corporation, right? And so they have the ultimate say as to what happens with your content, and they could just 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, 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, 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. So if they were to put that movie on a centralized server somewhere, then the company that owns the rights to 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 and 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 are 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 don't want to say 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, so 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 and could be easily accessible from multiple different places. So that's kind of the origin of what IPFS is.

00:07:28 - Ben Myers

Okay, so we're talking about, I guess, the fusion here being GitHub meets BitTorrent, right? GitHub is a centralized place to store your Git repos. It puts a pretty UI on it, but the real utility is that it's a centralized place to host your repos, right? But this is saying, no, we'll actually have it spread out across all the different nodes on the network, all the computers that are participating. 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

And this is kind of funny, actually, because GitHub is a centralized version of Git, but Git itself was already kind of a decentralized, distributed thing, because you would have multiple people with these Git repos on their computer. So if anyone ever lost everything, there are probably five other people with that same Git history, and so they can get the repo again. Now, this is taking that idea to its logical extreme, which is not only do we distribute it across multiple computers, we distribute it across multiple computers that are actually connected to a computer network. That's the really big difference. Some people say, well, Git was already decentralized. And I say, well, yeah, it was decentralized across a bunch of computers that only individual people had access to. So what if you distributed it across a bunch of computers and then took those computers and hooked them up to DNS or some sort of protocol that would allow people to 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. 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. 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, which 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, because when I first started doing this, I had no idea what any of this stuff was or how any of this stuff worked. It was really, really confusing to have to figure out. The docs are actually good, and the whole system is set up to be fairly ergonomic in terms of dev-experience-type stuff, but the mental model of what was even going on when I was doing it was so weird. It was literally the first time since I've gotten into web development where I felt like I was doing something genuinely new, like I was doing something I'd never done before, and it was really, really mind-bending. It took me a long time to put it into a sequence that I felt made sense and that other people could follow, and then it ended up being so long that I had a whole bunch of content for 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 probably not going to get into things like pinning services or hosting services for this. We're just going to show everything you can kind of do from your own computer. But yeah, as you're 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. This isn't saying that everything needs to be public and that you're just putting this all onto a giant network and have no control over what you're putting there. 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 you know it's backed up and safe and all that, then you can do that. In terms of the question of what this is for and what it isn't for, it is right now being aimed at being, literally as it says on the tin, what 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 you put HTML files onto it, because once you have an HTML file on it, then you can think about it like a web server and you're exposing that to the internet. So anything that you can do in HTML, 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 on it that customers will be using, because the network itself is still figuring out exactly how to be always reliable and up and stuff like that. The network itself doesn't really go down, but what happens is you have these gateways that give you access to the network, and there are lots of different gateways being run by different companies. Even Cloudflare has a gateway, and there's various levels of quality and uptime that go along with all of these gateways. So this is something where I have always been interested in kind of new, up-and-coming tech.

00:14:13 - Anthony Campolo

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

00:14:51 - Ben Myers

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

00:15:24 - Anthony Campolo

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. Think about just the problem of link rot. 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 go to a different hosting service. If they change their domain entirely, then you have all these links out in the world that no longer work, but the content may still be there, 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. So the link is the same, but the content is different. 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 hand, that permanence seems like it could be something that's ripe for abuse, because I could put doxing details out there, right? And it's a lot harder to have that wiped, I guess.

00:16:37 - Anthony Campolo

Yeah, 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 set this up in a way where it's a little more friendly to stuff like that, you're going to want to stick with things like Cloudflare, because then you're still going to be going through these more centralized services. And this is a 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 learn more about, and how that's going to be mitigated by systems like this. I think, for us, 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 worried about having your content doxxed and stuff like that, my general advice is be wary of what you put on the internet. If you're always careful about what you put on the internet, then you'll be less likely to be doxxed. But otherwise, you've got to find people you can trust that you share stuff with on the internet, and this is a huge, society-wide problem that we're all going to have to come to terms with at a certain point. Unfortunately, I don't have a ton of great answers for it.

00:18:14 - Ben Myers

Yeah, and I think the caveat I've got is that even if you do limit who you're trusting with information, you could still be the subject of a cyberattack, or a revenge-porn attack, or something like that. Someone who was unauthorized, or someone you once upon a time trusted, can still put content out on the web that you should not be held responsible for. And anytime you talk about permanence as enshrining a thing on a blockchain or a distributed network or something like that, these are things you have to deal with. Even when people are being their best, there are still going to be malicious actors who will take advantage of systems like that to abuse them and do terrible things. And I'm of the mindset that 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 that the solution is centralization.

00:20:01 - Anthony Campolo

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

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, so type ipfs init. You may have already done this, but if anyone's following along, this is the first step they need to do. This is going to initialize their repository. And you also see there that you have a peer identity. The peer identity is how, when you actually connect to the network, you're going to be able to find someone else on the network.

00:21:26 - Ben Myers

Gotcha. So what just got logged here 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. And you also see how it says reinitializing will 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 right now on your computer. Those keys are important. They've set the system up so they're on your computer somewhere, and I'm sure you could find them if you wanted to. I wouldn't even really know where to go to find them. So there's more education that needs to happen around what is actually public and private here, and what is locked down and what's not. For right now, we're just going to be doing simple HTML exercises, so it's not going to be a huge deal, but there are larger questions, like how this system is 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 when you first initialize it, you can't see it here, but it will usually give you this first command. Let me drop this in the chat. When you initialize, the first thing they do is say, hey, run this command here.

00:22:54 - Ben Myers

And...

00:22:55 - Anthony Campolo

And what's going on here is there's a content hash. A content hash is the first thing you really have to understand about how IPFS works. Because first off, what's a hash, Ben?

00:23:15 - Ben Myers

Right, yeah. 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 performing a lot of transformations on the content. Those transformations are lossy; you can't reverse-engineer them. But at the end of that process, you get a seemingly more or less random string, and if you had made even one tiny change to the content, you would have had a wildly different string at the end. So it becomes fairly straightforward to compare some very small, lightweight strings and trust that it's good enough. Now, multiple things can usually resolve to the same hash, but those things are usually so disparate and different enough that you wouldn't expect anyone to get those things confused. So if you end up with a hash and it's the same hash as what you told me to expect, then 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. That was all correct. And the important bit in there is that when you do the hash, the thing the hash spits out is globally unique. That's what makes it useful for this permanence idea, because 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. Once you get further down the line of using this stuff, you start asking, wait, how do I update my website? What you can do is have that hash point to another hash, and then that hash can stay the same while you update the content. That's something we may get to; we may not. We'll see how far we get. But let's actually, real quick, 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. I'm not sure if IPFS Desktop does this automatically, but this is a good thing to do regardless. You see all these IP4, IP6, TCP, UDP entries? This is where we're actually connecting to the internet now. Our IPFS node is now going to be able to take the content we're creating 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? And 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. That's all crypto stuff you don't have to 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 and then the readme after it. So what's happening here is that directories have content hashes and files have content hashes. If you use the directory content hash, then you can view other things inside that directory. So do that exact same command, but change it to security-notes. Let's see what this is. Yeah, there you go. So "we try hard to assure your system is safe and robust." They're letting you know this is alpha software and that it's a networked program. You always have 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 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 academic researchers. If the buck's got to stop somewhere, these are people who actually know how cryptography works and know how encryption works. So this is a relatively safe system at this point, as crazy new alpha software goes. But as we've been saying with the disclaimers, this whole thing is new. This is not something you should really put super-duper important sensitive 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 me try that real quick. If we take the thing that I posted in the chat and you go to...

00:29:50 - Ben Myers

Where are we going?

00:29:51 - Anthony Campolo

Sorry, 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. Then scroll up a little bit to where it says "a web." Yeah, so take where it says http://ipfs.io and then path. Grab that and then paste it in. Then paste everything from /ipfs/ onward from the Twitch command. So basically it'll have /ipfs/ and then the content hash. All right, 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. This is where all the important stuff kind of starts coming together, because this is where this becomes an actual website on the internet that other people can look at. So how is this possible? It's possible because of ipfs.io. That is the gateway I was referring to earlier. Protocol Labs themselves are running that gateway. They are managing it and ensuring that it stays up and reliable and available. There's also others, like Cloudflare. Cloudflare has an IPFS gateway. Let me grab a link for that. It's 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 started to really click together for me, because I was like, oh, okay, so the content hash is something that always stays the same, and you can reliably expect it to always stay the same. 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 can have different gateways, but the content will always stay the same. Once you figure out where the gateways are, then as the content is changing, you keep the same gateway, you change the content, and then you see all the different stuff on there. So I was 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. 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 put your standard HTML boilerplate in there, and you can say whatever you want. Say hello, put some links, anything like that.

00:32:57 - Ben Myers

Right.

00:32:57 - Anthony Campolo

I'd be curious: when you first start 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 to the...

00:33:08 - Ben Myers

I use... sorry, a weird 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'm just missing my snippet that I've usually got for this. Does this have any of my extensions or anything? 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 got that snippet from?

00:33:48 - Ben Myers

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

00:34:10 - Anthony Campolo

Yeah, I think VS Code is 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 the 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, call 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 <!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 show 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 I've always 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've 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 BrowserSync one that lets me run any web page as a local web server through the VS Code interface. That stuff's good. 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 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 to IPFS on stream, on a Some Antics 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 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. Then what we're going to do is run ipfs add, and before that you're going to do a -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 it, 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. Go ahead and run that command. If all went according to plan, we will now have two content hashes here. So drop both of those into 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. Let's see, which one should we do first? Do the cat command that we were doing before. Just go up through your old commands.

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 grab that whole thing with the index.html at the end.

00:39:45 - Ben Myers

Okay. So actually...

00:39:47 - Anthony Campolo

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

00:39:57 - Ben Myers

So I nuke this whole hash, right? Because 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 it's the contents of our HTML file.

00:40:17 - Anthony Campolo

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

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 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. 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 ipfs.io instead.

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?

00:41:28 - Anthony Campolo

Try both of them right now and see what happens. Let's hold off on that for a second, though. Let's pin it, and then that might help out. Pinning is an important part. When you talk about IPFS being permanent, and when you put something on there it's on there forever, there's a massive asterisk next to that claim, which is that if you don't pin the content, then your content regularly gets garbage-collected off of the network. That makes sense, because if every time everyone put anything on the network it stayed there forever, the network would explode in size in no time. So it's set up in a way where you can put something on your node and 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 can get kind of complicated. There are entire services now based around handling how you pin your IPFS content. But for now, let's grab the first hash that your...

00:42:32 - Anthony Campolo

...terminal spit out for you.

00:42:35 - Ben Myers

That's this one. 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.

00:43:08 - Ben Myers

Is that -ls? Okay.

00:43:09 - Anthony Campolo

Okay, cool. So that's the stuff that we have pinned right now. If you see the very last one, it has you pinned recursively. So 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 thinking. Is it secretly behind here? Is this your card?

00:43:55 - Anthony Campolo

Yes. All right, cool. So you see we're connected, and you can see bandwidth and metrics and stuff like that. Go to Files on the left.

00:44:14 - Ben Myers

Fun fact: clicking Files doesn't necessarily take you to Files immediately.

00:44:19 - Anthony Campolo

Yeah, I imagine it's just lagging because of the stream. All right, so right now we don't see anything. Click Import on the top right.

00:44:29 - Ben Myers

Okay.

00:44:30 - Anthony Campolo

And let's do it from IPFS. Then do the path for your content. It'll be just /ipfs/ and then that.

00:44:45 - Ben Myers

Okay, like 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. You see how it has pinned status next to it? 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 let's do 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. 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

It's trying to actually come up on my computer. This is where stuff always gets a little wonky, and why I would usually recommend that 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's what you want to do?

00:46:32 - Anthony Campolo

Let's do it. Yeah, create a Fleek account really fast. It should be fleek.co... 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, because why wouldn't we have this, is 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 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.html 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 the 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. Did it get me all signed in? 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. All right. Oh boy. Let me real quickly go into privacy mode.

00:49:14 - Anthony Campolo

And if people have questions in the chat, now would be a good time to start dropping those. Hey, it 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 are 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 to update your website, you don't have to also update the content hash every single time. There are ways to do this with IPNS, the Interplanetary Name System, which is like a DNS for this. 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. Then you have a DNS record, a DNS text record, that points to your IPNS name, which points to the content hash. So there are ways to do it so a regular old HTTPS request can find that content hash. But there are a lot of steps in that chain. There's a lot of knowledge about DNS and the architecture of the internet. 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. So you just point it to this other thing, and then it'll go down the chain. That's the kind of stuff you don't really want to have to do yourself and would be nice to offload to a service. And also, we want a service that's going to let us point to a Git repo and, every time we make a change, 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 guess, it's going to be auth with GitHub Mobile. Oh no, it isn't. Okay, cool, we're good. In that case, let me turn off privacy mode.

00:51:29 - Anthony Campolo

Yeah.

00:51:32 - Ben Myers

Let me confirm our friends at home can now see what we're seeing, which is a big Authorize button.

00:51:49 - Anthony Campolo

Yeah.

00:51:50 - Ben Myers

With that, finally we'll choose that one. Then should I go ahead and choose IPFS?

00:52:02 - Anthony Campolo

Yeah.

00:52:04 - Ben Myers

Cool. I'll scan this a bit. All right, so 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.

00:52:24 - Ben Myers

It's so underground no 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 have 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 instead of it being this roundpaper7017, I could call it... oh man, this really is Netlify for 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 IPFS end.

00:55:35 - Anthony Campolo

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

00:55:39 - Ben Myers

Yeah. So I'll go ahead and add in another paragraph tag with another lorem ipsum. Boom. Right, so Fleek is already going to take care of this. Cool. What kind of stuff is it abstracting away from me for 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 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 the more Web3 people can embrace this hybrid centralized-decentralized model, the quicker we're going to 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 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 it can also point to an IPFS content hash. 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 a database. This is why it's really important, if you are going to get into NFTs, that you understand where this NFT actually lives. Does it actually live on a decentralized system, or is it just on someone's computer somewhere? Because 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. That's why having an NFT that is actually on IPFS is important. 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 or NFTs; 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 Some Antics, 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 real things. So Lindsey's coming back on this Friday at 2 p.m. Central. We're going to be building Elm apps, so absolutely follow Some Antics 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'all.

01:03:44 - Anthony Campolo

All right, bye, fam.

Discover Related Content

• A First Look at IPFS - The written guide Anthony references as his primary research for this stream, covering IPFS initialization, content addressing, pinning, and deploying HTML through public gateways
• IPFS with Daniel Norman - Podcast episode going deeper on IPFS concepts — content addressing, Web3 ownership, and how decentralized storage bridges traditional and decentralized web development
• Web3 is Jamstack by Default - The week-prior Jamstack Boston talk where Anthony introduces IPFS and Fleek in context of the broader Web3/Jamstack overlap, providing background for why this IPFS demo matters
• A First Look at Ethers and Hardhat - Companion guide to the blockchain layer that IPFS often pairs with, covering smart contracts and Ethereum deployment for readers who want to connect decentralized storage to decentralized compute
• A Crash Course in web3 for web2 Developers - Broader Web3 workshop for frontend developers that contextualizes where IPFS fits alongside smart contracts, wallets, and dApp architecture