Web3 is Jamstack by Default

Episode Description

Anthony Campolo explains Web3 fundamentals and demonstrates building a Svelte dapp that deploys a smart contract to Ethereum's Ropsten testnet.

Episode Summary

Anthony Campolo returns to Jamstack Boston to bridge the gap between traditional web development and Web3, starting with a clear distinction between decoupling (separating front end from back end) and decentralization (collectively owned networks). He uses a simple ledger analogy to explain how blockchains work, then walks through Ethereum's key innovation — smart contracts — which allow developers to embed immutable programs on the blockchain. The core demo shows a Svelte application that connects to a Solidity smart contract via Ethers.js, compiles and deploys it to the Ropsten testnet using Hardhat, and then interacts with it through a MetaMask wallet. Along the way, the discussion touches on security concerns like wallet-signing scams, the role of contract auditing firms, and why gas fees serve as a security mechanism against network spam. Anthony argues that Web3 is inherently Jamstack because the decentralized back end must always be queried from a separate front end. He also addresses common criticisms, distinguishing bad actors from builders, and points to emerging areas like IPFS for permanent content storage, the Lens Protocol for decentralized social networking, and services like Fleek for hosting. The talk closes with learning resources, including Patrick Collins' free course and Nader Dabit's tutorials, and encouragement for developers to approach the space with healthy skepticism.

Chapters

00:00:00 - Web3 Meets Jamstack: Core Concepts

Anthony Campolo introduces himself and frames the talk around the intersection of Web3 and Jamstack architecture. He explains that Jamstack is about decoupling front ends from back ends via APIs, while Web3 introduces decentralization — a back end collectively owned by network participants rather than a single entity.

Using a coin ledger analogy involving three people tracking shared account balances, he makes the concept of blockchain consensus tangible. He explains why blockchains started with currencies, how 51% attacks threaten networks with concentrated ownership, and why the blockchain functions as a queryable API that front-end developers can build against with familiar tools like React or Svelte.

00:05:11 - Nodes, Smart Contracts, and Immutability

Jim asks whether a monolithic app could still query blockchain APIs, prompting Anthony to explain why the decoupled architecture is essentially mandatory. Since blockchain nodes form a consensus network that developers don't individually control, the back end is effectively fixed once deployed — similar to how developers don't rewrite TCP/IP for each new web app.

Anthony then introduces Ethereum's key advancement over Bitcoin: smart contracts, which let developers embed programs directly into the blockchain. He explains why they're called contracts — once deployed, they can't be revoked — and touches on the security implications this creates. The conversation also briefly covers IPFS, crypto wallets, private keys, and how Web3 shifts the technology's center of gravity from platforms to individuals.

00:10:51 - Setting Up the Development Environment

The discussion shifts to practical tooling as Anthony prepares to show the code demo. He explains EVM compatibility and why alternative chains like Avalanche exist to address Ethereum's speed and cost issues. Jim raises an interesting comparison between blockchain's append-only history and tools like Git and Docker Hub, leading to a discussion about how blockchain guarantees community-owned, tamper-proof history.

Anthony walks through the development setup: the Solidity smart contract defining a "wave" message struct, the Hardhat configuration for compiling and deploying contracts, the Ropsten testnet as a free development environment, and how QuickNode provides blockchain endpoints. He also shows MetaMask wallet setup and explains the role of private keys and faucets for obtaining test Ether.

00:23:44 - Smart Contract Security and Auditing

A question about smart contract auditing leads Anthony into an important discussion about security in Web3. He recommends Trail of Bits as a well-known auditing firm and explains why contract auditing matters so much — every bug in Solidity code could mean users losing real money, making the stakes fundamentally different from typical JavaScript development.

Jim asks whether blockchain technology must always involve financial transactions. Anthony explains that gas fees function as a DDoS prevention mechanism and also compensate node operators, but notes that IPFS offers a free, non-financial alternative for hosting content. The conversation then turns to whether blockchain could solve open source sustainability by building payment mechanisms directly into protocol governance, with Anthony describing models where mining rewards are allocated to core developers.

00:29:13 - Live Demo: Deploying and Interacting with the Contract

Anthony returns to the screen share to compile the Solidity contract with Hardhat and deploy it to Ropsten. He explains that Ethereum's roughly 12-to-14-second block time is why deployment takes a moment, then walks through the Svelte code that connects to the deployed contract using Ethers.js — checking for a MetaMask wallet, creating a provider object, and translating blockchain RPC calls into JavaScript functions.

The demo proceeds through connecting a wallet, signing transactions, and writing messages to the blockchain. Jim asks about the trustworthiness of wallet signing prompts, and Anthony explains the information gap that enables scams — transaction details are technically visible but most users skip past the JSON data without understanding it. He emphasizes being cautious about connecting wallets to unfamiliar contracts.

00:44:16 - Deploying to Vercel and Decentralization Trade-offs

Anthony deploys the finished Svelte app to Vercel, demonstrating the Jamstack nature of the project — the messages written from localhost persist because they live on the blockchain, not in a local database. This illustrates how the decoupled architecture means the front-end deployment target is irrelevant to the back-end data.

He discusses the pragmatic trade-offs of using centralized services like Vercel and QuickNode while building on decentralized infrastructure. The key insight is that Ethereum remains decentralized even when accessed through a centralized node provider, and developers can swap providers without changing their application. He contrasts Vercel's embrace of Web3 with Netlify's skepticism, and addresses common criticisms by distinguishing builders from bad actors in the space.

00:53:25 - The Future of Web3 and Learning Resources

The final chapter covers the broader trajectory of Web3 beyond finance. Anthony highlights decentralized social networks — particularly the Lens protocol — as the next major frontier, along with IPFS and Arweave for creating permanent web content. He mentions Fleek as a Jamstack-friendly service for deploying to IPFS and discusses how DNS-to-IPFS bridges and crypto-native domains are being developed.

For developers wanting to get started, Anthony recommends Patrick Collins' free 32-hour JavaScript-to-Web3 course, Nader Dabit's end-to-end tutorials, and QuickNode's own guides. He encourages healthy skepticism toward all technology claims while noting that blockchain is built on decades of rigorous cryptography research. The session wraps with audience engagement and Anthony's offer to help developers entering the space.

Transcript

00:00:01 - Anthony Campolo

Hello everyone.

00:00:03 - Jim (host)

Now you're good.

00:00:04 - Anthony Campolo

Hello everyone. Thanks so much, Jim, for having me back. This is my second time speaking at Jamstack Boston. I originally was here, it was over a year ago now. I think that was talking about StepZen, which is a GraphQL API company. But I have transitioned out of the. Well, sorry, I transitioned out of the GraphQL world to the Web3 world and as soon as I started working at this company, the Web3 company I was at bought a GraphQL company. So it's going to be some interesting crossover there, but we're not going to get into that today. But I'm working on some blockchain NFT GraphQL guides right now, which is super fun. But we're just going to talk about today: basically what is Web3 and how does it intersect with current web technologies, especially the Jamstack? Because the Jamstack is this idea of how do we build websites or web apps that are decoupled. You have your front end, which can be just like a static front end that's querying some sort of back end and all you need to do that is an API from that back end. And then they don't have to live together in the same project.

00:01:09 - Anthony Campolo

They don't need to be this complicated monolith that requires 30 minute long deployments and all that. For someone who's heard of the Jamstack, you probably heard the pitch of why it's a useful thing, but it gives you more resilience, more reproducible, nicer DX kind of experience. And what's interesting about blockchain is that the blockchain itself is like a backend API in a certain sense. Now it's different because it's decentralized. So I would first talk about like what is the difference between decentralization and decoupling? Because you mentioned that in the intro. So with decoupling, it's about having an app that's made up of pieces that are separate but communicating with each other. So that's usually a front end and a back end and they're speaking to each other over a REST endpoint or GraphQL endpoint or RPC calls or something like that. But what's cool about blockchain is that it allows you to do that, but you're not hitting a centralized API. So that's the thing is if you're hitting an API, usually you're hitting Contentful's API, you're hitting a WordPress API, you're hitting an API that is owned by an individual or a corporation or some.

00:02:24 - Anthony Campolo

Some sort of entity. Whereas with a blockchain, it's an API that is collectively owned by the set of people running the network. So that's what they mean by decentralization is that you can't run a blockchain on a single computer if you just have like, one computer running a blockchain. Like, that's not a blockchain. A blockchain is a bunch of people who have, like, a database on their computer that is a shared ledger that allows them to track things like transactions. To simplify that down to a basic example, imagine that me, Jim and Stephanie, we all want to invent our own coin. We want to invent Jamstack Boston coin. We're going to start off where each of us are going to have 10 Jamstack Boston coins, and each of us have a ledger on our computer saying each of our account balances. And if I want to send Jim five of those coins, then all three of us need to update our ledger saying, I now have five, Jim has 15, Stephanie still has 10. And so we will all update that on our own blockchains. And then the blockchains together have a form consensus of what is the correct state of the world.

00:03:32 - Anthony Campolo

And the reason why this is something that first started in currencies and with cryptocurrencies is that we think about like, you can't defraud this, because if you try and give yourself a million dollars, all the other people in there are like, wait, you don't have a million dollars. That's not in my ledger. So it allows people to kind of keep each other in check in that respect. And this is why people will talk about how decentralized is a blockchain. So if you think about if you have a blockchain and there's 100 computers running that blockchain, and one person owns 99 of those computers, then they could just change it. So there's these things called, like, 51% attacks. But that's kind of the main idea, is that you have a bunch of computers that form a network, and then that network holds data that people can interact with. That data can represent money, it can represent art, it can represent financial algorithms, it can represent essentially anything you can think of. But the cool thing is that because it is just an API, you're going to query it from a front end. Once you start getting into this Web3 stuff, you're going to start seeing all these examples.

00:04:39 - Anthony Campolo

And it's like React applications that are just like hitting this contract address and then getting this data back and then displaying it in React components or Svelte components or something like that. So this is something that I was saying before I even got a job at QuickNode, is that you can't build a Web3 application that is monolithic. It's literally impossible because of the fundamental architecture of it. So, thus Web3 is Jamstack by default. So questions from that first spiel, anybody?

00:05:11 - Jim (host)

So I guess so. I love the pitch, that clears up a lot of things. But I'm curious, I mean, couldn't you have a monolith sitting on a server that has a front end and a back end and query these APIs or what? I guess, what is the challenge between having your front end be distributed and interacting with the decentralized nature of blockchain?

00:05:34 - Anthony Campolo

Yeah, because the blockchain itself is made up of a bunch of what are called nodes. So a node is like a server, basically, and they're all servers. You can run them in your house, you can run them on aws, you can run them on Digital Ocean. So Quick Node is a infrastructure provider that runs nodes for, for you and then gives you access to a kind of global API. So it wouldn't really make sense to run the node and the front end together, because if you change, if you're trying to develop and you make a change to the node, that change doesn't mean anything until that change is accepted by all the other nodes on the network. So the back end is controlled by a decentralized, distributed group of people. So you don't really have ultimately control over the back end that much unless you get into a blockchain that has governance built into it, where you can vote on stuff with your tokens. That's kind of like a huge rabbit hole. But the main thing is that the blockchain, usually once it's deployed, it doesn't really change. That's why you don't really develop with the front end and the back end.

00:06:40 - Anthony Campolo

Once the blockchain is out into the world, it's like a protocol that you're going to interact with and you don't rewrite TCP/IP when you're developing a web app, it's just the same. And HTTPS is the same. It's always going to be the same. So the blockchain is kind of set in stone to a certain respect, and then it needs to stay up and running. So you need people running these nodes, you need people running the back end. But for the people actually developing what are called dApps, decentralized apps, all they're doing is developing a front end that's querying this blockchain protocol that was already defined in code.

00:07:14 - Jim (host)

Yep, that makes a lot of sense. I mean, that's kind of like the whole idea of the jamstack, right? Is these microservices calling out to them to do work that you can't do in just your front end. So, yeah, that makes sense. Cool.

00:07:25 - Anthony Campolo

And so a couple just other terms that would be good before we actually start looking at the code is when you are talking about this kind of stuff, usually people will think of. Bitcoin is typically the first kind of blockchain application that most people became aware of and would kind of spark this whole craze. But what's interesting is that Ethereum added additional functionality that Bitcoin didn't have. And so what Ethereum did is Ethereum gave developers the ability to actually embed a program in the blockchain. So before, what it was is you had wallets that held funds and you could write logic that would transfer funds from one wallet to another. And that's what Bitcoin was. It was a currency. And everything about it was kind of around that idea. But with Ethereum, they're like, okay, what if we take the same idea but we allow people to actually write a program? What if we allow someone to write like Uber in the blockchain and then you could deploy this back end and if you could write Uber in one go, you know, so that's kind of like one thing, is that you're, you're going to be writing these things over a long period of time, kind of adding functionality.

00:08:34 - Anthony Campolo

It's usually additive kind of thing. But with smart contracts, you can embed a program into the blockchain. And what's really cool about this is that they call it a contract because you can't change it. So once you actually deploy this and it has a certain API that people are going to depend on, they can depend on that forever because it's baked into the blockchain. You can't rewrite the blockchain history. So you can update a smart contract, you can create a new smart contract that changes it and then you could try and get people to upgrade to it. But you can't revoke a smart contract once it's deployed to a blockchain. So it gives you a certain amount of security in terms of we build on so much open source stuff that's just constantly changing. We build on so many services that are built by startups that are constantly rewriting their stuff. So I feel like just having software that is intrinsically stable is a really interesting idea. And this also gets into things like ipfs, which allows you to actually save content in a git like form. That'll be another talk that I'll have to give someday.

00:09:40 - Anthony Campolo

But the idea is that you can have things be immutable on the blockchain, and then also you are accessing it through what's called a crypto wallet. And this is why a lot of people will talk about terms like ownership and permissionless when they talk about Web3. Because anytime you're interacting with a blockchain, you have a crypto wallet and you have a private key with that crypto wallet and you own that. And that's the entirety of the whole deal with everyone involved. And this is a little different from something like Coinbase, because Coinbase kind of holds your keys for you. But for the most part with Web3, it's like a technology that's centered around individuals versus traditional web platform stuff, which I think is based more around platforms. You think about who benefited the most from web up to this point is Google, Facebook, Apple, Microsoft, you know, but this is a technology that actually is built around individuals and how individuals interact with the blockchain and how they can get value from these applications. Cool. We can get to the code.

00:10:51 - Jim (host)

So is the code that you're showing, is it built on Ethereum since you can write programs in that blockchain, or is it something else?

00:10:58 - Anthony Campolo

Yeah, I said in the original meetup description that was going to be avalanche, but the two are almost identical for the sake of Web3 beginners doesn't really make much of a difference. But yeah, so it is Ethereum, it's not Avalanche, but there's these other chains that are coming out that are what are called EVM compatible, which basically means they want to give you the ability to. To write a program exactly the same as Ethereum, but then deploy it on a different blockchain. Because Ethereum is kind of slow and ridiculously expensive and has problems associated with it. That's because it's established and everyone's using it. So there's this kind of race to build the next Ethereum and some people will do that by building a whole new programming language that's not solidity. And then some people will do it by building a whole new blockchain. The same programming language.

00:11:48 - Co-host / moderator

Yeah.

00:11:49 - Jim (host)

So this question maybe is missing the mark on some of the stuff you're talking about. But you know, we have these things, these tools and I don't think these are exclusive of what you're going to show. But you know, we have things like Git and we have even history that can be kind of laid out and for programs in like Docker. So like Docker Hub can have like a history of releases and things like that. Is the idea behind releasing programs on something like Ethereum that not only is that his, that history is no longer essentially controlled. So like I could have an open source project, but I could at some point take it down from GitHub and destroy my Docker Hub and get rid of that.

00:12:21 - Anthony Campolo

So like it's rewrite your git history. And yeah, I could, I could force,

00:12:25 - Jim (host)

push and change that history. And the idea here is that like that is owned by the community, like truly and that cannot be changed. Although I could continue releasing new things. It's not like I've locked myself into an old way of thinking I could change things, but everybody in the community has access to the full history and can revert or stay at any point in time. Is that kind of the thinking?

00:12:46 - Anthony Campolo

Yeah, because it's an append only log. Everything about you can add something to it, but you can't take something off of it. Unless enough people on the chain collectively decide that someone wrote a program so bad that we all need to collectively decide to reverse it. Which did happen once. Ethereum had a program that had a bug in it that led to hundreds of millions of dollars just like disappearing. A core team basically said we're going to fork it. We're going to go back to the point before we mess this up and then we're going to make that the chain. Yeah.

00:13:16 - Jim (host)

And what about the case where, okay, say I'm a small developer and I'm working on something and I, I release API keys or things like that, security vulnerabilities in there. I'm kind of, I have to get consensus from the community now to revert or change that. Is that.

00:13:31 - Anthony Campolo

So when it comes to the private key kind of stuff, if you are using tools that allow you to kind of like embed a private key into it, you can kind of swap stuff like that out a little more easily. So there's like, there's, there's things in the blockchain where you expose certain APIs that can't really be changed. And well, I guess is, it's, it's true that you would, you would need to like change that the contract address ultimately because you can, you can always basically like Roll your keys essentially and redeploy the contract. And then the contract will be mostly the same and people will still interact with it the same, but it'll have a different contract address. So if a contract gets compromised, you need to fix it. You deploy a new contract and then you give people that contract address and then they swap it out. So that's one of the things I'm going to show in this example is we're going to deploy like very simple smart contract. We get that address, we get put in our app and then we're going to like kind of query it. Great.

00:14:29 - Jim (host)

Cool. Excited to see it.

00:14:30 - Co-host / moderator

Yeah.

00:14:32 - Anthony Campolo

And then as I'm going, like, people feel free to stop me and ask questions at any point.

00:14:38 - Co-host / moderator

So I'm going to share. How do I share? Oh, there we go. Bam, bam. All right,

00:14:51 - Anthony Campolo

cool. So let's start off by just looking at kind of what's happening in our project here. So who knows Svelte here, aside from Jim, Probably Brittany. Yeah, she would be the other Svelte master here. Yes. Svelte is a front end component library similar to React with some certain architectural and syntactical differences. But the most important thing is that you have a root component which, which is hanging out here, your app component. And in our app component right now, I have a lot of things commented out. I want to just start us off with our simple Svelte hello world. So we all start on the same page here. This is going to do is this is just going to display a little div. That div is going to have little waving emoji and then H1. And the reason why it says wave to AJC web dev is because the application is going to allow you to basically write a message to the contract and then that message gets saved on the blockchain. And I talked about this a little bit before we start recording right now. This is using like roll up and kind of like the old school way of doing Svelte.

00:16:17 - Anthony Campolo

Eventually we're going to figure out how to do this with Sveltekit.

00:16:20 - Co-host / moderator

Then that's going to be the move. Let me do this in Chrome.

00:16:29 - Anthony Campolo

Here's our Svelte component.

00:16:31 - Co-host / moderator

Just saying wave to ADC web dev

00:16:34 - Anthony Campolo

on the add

00:16:38 - Co-host / moderator

hello from Jamstack.

00:16:46 - Anthony Campolo

I don't know why.

00:16:46 - Co-host / moderator

It looks also like an H1. That's weird.

00:16:51 - Anthony Campolo

Now there's going to be the Svelte project and then there's going to be the web. Three parts of the project. Now that we have our Svelte application set up, let's Just look at what are the web three things that are happening here. Now, this is our smart contract. You're going to notice here that this is a programming language that will look foreign to you, most likely, unless you already know solidity. But it's similar to C and JavaScript. And Java takes bits and pieces from other well known programming languages. So you have things like enums and structs and then un and arrays and events. So most of this stuff should be fairly comprehensible. But just go through it. What's happening here is we're defining a wave. And so the wave is just a little message and then the message will include the address of the person who is sending the message. So if anyone out who's watching this also has like a crypto wallet already installed in their browser, they can interact with this project. And then you have a timestamp that's going to timestamp the message that they're going to send. And then we're going to have a array that's going to save all the waves together.

00:18:06 - Anthony Campolo

So as multiple people add messages, it's just going to keep a whole list of those and then we're going to display that list on the page and then we have a new wave. So anytime a new wave comes in, that's going to then have the functions that are going to either wave, get all waves or get total waves. Most of the important stuff is happening here in the wave function and it's taking in a reaction, which the first version of this application had. You could wave or you could send cake, or you could send a message. There's no reactions anymore. I took that out to simplify the application. The message is the more important thing. It's going to take in a message and then it's going to basically push that message onto the wave list. So every time a message comes in, it adds that message to the wavelist array. And then if we want to see all of those messages, then we can do the get all waves. And then we can also get a number of how many waves there are. With waveless dot length. This should be fairly comprehensible if you know, general programming constructs.

00:19:18 - Anthony Campolo

The syntax may look a little weird, but all that's really happening here is we're defining a struct, defining an array and then pushing kind of like objects onto that array. But since this is just solidity code, you may be thinking, well, how do I get this thing on the blockchain though? And the way you actually get this thing onto the blockchain is with Hardhat. Hardhat is a developer tool that makes working with blockchains really, really easily. So what's happening here is we're going to tell it that we want to deploy our Wave Portal contract. We first defined this contract. We just write the contract word, then give it a name and it's like an object or constructor thing. Then we're going to run the get contract factory and then we're going to run this deploy command. Then what this does is you can tell it which blockchain you want to deploy it to. We have this hardhat config file right now and we're going to tell it to deploy to the Ropsten chain. So when you're getting into this kind of Web3 stuff, you're going to hear about a lot of different blockchains and there's a lot of terms.

00:20:39 - Anthony Campolo

It's going to be really confusing. I would recommend kind of like the first thing you should learn is learn Ethereum. But when you learn Ethereum, you actually realize you don't deploy to Ethereum because if you want to deploy something to Ethereum, you got to pay money. So you don't really want to have to pay $10 in gas just to build a hello World application. So what you do is you deploy it to Ropsten. Ropsten is like the fantasy version, fantasy parallel version of Ethereum that people can interact with in essentially the same way, but all the money is fake money. You don't actually pay for the money. So you can just go into what's called a faucet and ask for Ether on Ropsten. They just give it to you. It's just free. So when you're developing this kind of stuff, you're going to develop on a test net and you're going to deploy it to a test net. You're going to test it on the test net. And then once you've done that many times and hired various companies to audit your contracts, then you deploy it to actual main chain. So today we're going to just deploy it to Ropsten.

00:21:34 - Anthony Campolo

But it's going to give you a good idea of like, what does it mean to kind of get something onto a blockchain. Now I'm going to hop off screen for a second. So there's going to be two things I'm going to have to put in here that I don't want to expose. There's going to be the endpoint for our Ropsten URL. Now, this is what we're going to be getting from quicknode.com so this is the company I work for. This is a blockchain infrastructure company. So what's really great about QuickNode is that it allows you to very, very simply get spun up with an endpoint. So right here we can see our endpoint and I'm not going to show the whole thing because at the end of the endpoint is essentially like an API key. You don't want to expose your actual endpoint to the world. You always want to keep this in an environment file or something like that. All you do is just grab that endpoint and then put it right here. Then you also need a private key for a wallet. This is what I was talking about before, how when you deploy these things it's associated with a specific person's wallet.

00:22:42 - Anthony Campolo

I have MetaMask over here and for people who aren't familiar with MetaMask, it's kind of the most popular, well known browser based wallet. So when you're getting started, you usually start with MetaMask and then in MetaMask over here you can get set up on Ropsten Testnet and then you can see here, I already kind of sent some Ropsten to myself on the Ropsten faucet over here. So if I were to do this again, I would just grab my address here, copy to the clipboard, put it there and then give me Ropsten. And this is similar to what you would do if this was real money and I wanted to transact with, say, Jim. Jim would send me his wallet's public address and then I would be able to send him money from my wallet. Any questions so far on all that?

00:23:44 - Jim (host)

Yeah, I had a quick question.

00:23:45 - Anthony Campolo

You said you can actually hire companies to audit your smart contracts. Do you have any, do you have any company names or I guess anything I can just kind of do a quick search on to learn a little bit more about that. Yeah, so trail of bits is one that I know is very established, has been around for a while, so that would be the first one to look at. There's definitely many more and that I'm not aware of. But it's a very specific specialty now where once you put so much money into a system like this and then it's all exposed through a single programming language. Think about how many bugs have been in JavaScript code throughout your career. Imagine if every time there was a bug in your JavaScript code that meant one of your users could steal your other user's money. That would be a huge issue and you would probably Think differently about how you write that JavaScript code. So with solidity, you need to basically go over every single line with like a fine tooth comb of like, what is this line of code doing? How does that interact with the evm?

00:24:49 - Anthony Campolo

What is this line of code compiled down to? What is like the entire access chain involved with that? So this is why if you want to actually like put a smart contract out into the world that actual people's funds are going to interact with, you should hire an expert to go over that contract for first to make sure that you're not going to deploy this. And then everyone's going to instantly get their money stolen.

00:25:12 - Jim (host)

Got it, thank you.

00:25:15 - Anthony Campolo

This is why you hear about so many scams in the, in the space, right? Like we're constantly hearing about, you know, so and so gets hacked and so and so loses $100 million and you know, so and so gets their board ape stolen, all this kind of stuff. Because any bug is like very, very consequential. But at the same time, if all the stuff has like the reason why people are trying to steal from this because it's generated so much value also. So that's like another thing to keep in mind.

00:25:40 - Co-host / moderator

Okay, I need to actually grab those. I was talking instead of doing, but I'm gonna grab those and I go,

00:25:56 - Jim (host)

Anthony, while you're doing that, does this technology fundamentally have to be financially related? I mean, so I know we're using MetaMask and we have wallet addresses. Like there could be applications of this that are not related to money or you, I guess you always need it to deploy and interact with the network is that.

00:26:14 - Anthony Campolo

Yeah, this is, this is a common question. I get. So the reason why there's always going to be money involved with a blockchain is because if you could do, if they gave the ability to interact with it in a way that doesn't require some sort of payment, then they have no way of guaranteeing that people aren't going to DDoS the network basically, and people aren't going to spam it and just run the whole network down. So the fact that you have to pay to use Ethereum, the fact that GAS exists at all is a security mechanism actually. And then it also has these knock on effects which is that the people running the network actually make money. Because if you think about so many people are doing these open source projects and building all this code and they're not being compensated for it. So to me it's kind of acknowledging the reality that computers aren't free computing power Isn't free. Human time isn't free. Now I will say though, I mentioned IPFS very briefly. IPFS is not a blockchain, but it's very similar to blockchain. You could think of it like Pirate Bay and Git had a baby.

00:27:16 - Anthony Campolo

That's what IPFS is. And so with that you don't have to pay. Like you can push something onto ipfs. You could put a website on IPFS and then you could like give people this like long ridiculous content hash representing your website and that's all free. So there's stuff in web3 that's based more around like actual putting websites up on the Internet that is free. And so I think that's, that's pretty cool and worth looking at.

00:27:38 - Jim (host)

So this maybe is a little philosophical, but do you think that this. So I think open source is awesome. I'm a huge advocate for it. But it struggles to find a business model that makes sense for a lot of folks without, you know, resorting to like open core or other types of things, you know, dual licensing, that kind of thing. Do you think that this technology can solve some of that problem? So it's like it's kind of forcing payment and interaction in order to use apps and make it make sense that way.

00:28:08 - Anthony Campolo

Or is it, I will say it's at the very least is introducing novel ideas to tackle these problems, which I think is really important because you are always going to be at the end of the day deciding on like resource allocation. Because even if this blockchain is still generating all these coins that are worth all this money, it's still a question like, well, who gets those coins? And that's where all the math with the miners comes in of like, who gets how much for mining what kind of block and stuff like that. But the more interesting stuff is you could actually write your blockchain from the start where you say, okay, 20% of all coins mined are going to go to core developers and it's just going to be there. And then once people vote on who the core developers are, they will get paid out. So there's mechanisms like that. And then you get involved in voting and weird social stuff. And so it's not like a silver bullet, but it's at least an attempt to kind of build in financial mechanisms in these things to make sure that the developers get paid.

00:29:10 - Jim (host)

Sweet.

00:29:13 - Co-host / moderator

Okay, let me get back to the screen sharing.

00:29:20 - Anthony Campolo

Just to recap what I'd done here. I have this smart contract and I have this deploy script. What I'm going to do now is I'm going to run yarn hardhat compile. What that did is it took our smart contract and it compiled it and you can then actually take that binary and then shove it up onto the blockchain. So the next step we're going to do is yarn hardhat run and we're going to just run that deployment script and then we're going to give it a network flag that's going to specify the Ropsten test network specifically.

00:30:03 - Co-host / moderator

Then this step can sometimes take a long time.

00:30:08 - Anthony Campolo

This may take like 10, 15 seconds. But basically the reason why this takes a long time is because Ethereum produces a new block every like 12 to 14 seconds. So if you want to write something to Ethereum, you submit it. The Ethereum nodes receive those over the course of 12 to 14 seconds. They assemble the blocks and then the blocks are declared and then they're made part of the the blockchain. So that's why it takes a little bit of time. But once it is done, you have your contact address. So this is our contract for our smart contract. And to interact with this, we're going to put it in our project here.

00:30:55 - Co-host / moderator

So let me first uncomment just

00:31:04 - Anthony Campolo

so I'm going to change that contract address. We're going to set it to a contract address variable. Then this is the more web3library stuff. This is letting you basically connect to a blockchain with three lines of code, which is really sweet. What this is doing is it's first checking do you have a crypto wallet at all? So this is going to check the browser's window actually, which is like if you know the window object, it's like you need to go all the way up to the chain to see like what's actually happening in this web browser. So you go to the window and you see, does this person have an Ethereum wallet? So that's going to check to basically see do you have MetaMask? If you do have MetaMask, it's going to say, okay, cool, this is now your provider. This is the representation of you as a user. We're then going to take that provider, your smart contract, and the application binary interface associated with it and the contract itself. And then we're going to create a contract object that you can interact with in JavaScript. This is what's really cool. If you're a JavaScript developer, this is going to do this whole translation from blockchain into JavaScript for you.

00:32:21 - Anthony Campolo

So right now where you get to write JavaScript code to interact with the Blockchain. Even though ethereum doesn't speak JavaScript, there's no concept of JavaScript in Ethereum at all. But with something like Ethers, they allow you to basically say, okay, we're going to write this API that's going to take RPC calls that you would need to write to interact with Ethereum and then turn that into JavaScript functions. That makes it super easy for JavaScript developers. Then you get to just run a JavaScript function that corresponds with your smart contract function. This GetAllWaves smart contract function is now a ethers JS JavaScript function that will then just give us an object which is all of your waves. This is just some normalizing your timestamps to make sure they look nice. Then it uses svelte on mount to

00:33:18 - Co-host / moderator

actually mount that to the thing.

00:33:23 - Anthony Campolo

Okay, so there's gonna be a lot of code here, but I'll try and

00:33:31 - Co-host / moderator

be as succinct as possible with this. People don't get too confused. Oh, I know what, I know what I did here.

00:33:39 - Anthony Campolo

We got three components that is making up the majority of our application. We have our wallet component, and so our wallet component is what's checking that we have a MetaMask wallet. And then it's looking through your wallets to like, kind of grab an account. Because you can have multiple accounts in a wallet. Don't worry about that too much. And then we're going to give you a button that you can click to connect your wallet. So that is the really important thing to always be aware of as you get into this stuff is that don't click random buttons in web3 unless you're like comfortable losing your stuff. Because anytime you connect your wallet, you are kind of trusting that service that is not going to have code that's going to be malicious. So anytime, if someone just is ever sending you random crypto spam, they're like, hey, Airdrop, you had a free thing connect your wallet. Like, that's not a free thing. They're stealing your thing, actually. So, like, be very wary of that.

00:34:44 - Co-host / moderator

Let me get this going now.

00:34:55 - Anthony Campolo

So now we have our components on screen and we're going to have the connect to metamask button. We're going to have an input field to write our message and. And then the wave at me button is what takes that message and then sticks it on the blockchain for you. So let's first just start by connecting our wallet. I also am console logging some stuff here that may help you out a bit. Okay, so I was already Kind of logged in and have been connected to this before. So it kind of recognized and was like, hey, you want to connect to this again? Cool. And this is where you can see your wallet is actually connected to it. And then here is telling us our Ethereum, our actual wallet address. So this is what I was saying, how when you check for your MetaMask wallet, it sets it to the provider objects and that provider object is like you, like, this is my wallet's address and this is like something that identifies me if I ever post this address out into the world. So we're connected now and we can actually interact with the wave. So let's see, how do we actually do that though?

00:36:08 - Anthony Campolo

Now what we need to do is instead of just connecting our wallet, we need to sign a message so that anytime someone writes a message to the smart contract, they have to sign it with their wallet. So basically it's like signing a cryptographic key or it's like, you know, put, putting in a password. So it ensures an extra level of security that this is who they say they are. And then it also ensures that there's a ledger of all the changes and who made those changes. And this is the stuff I was talking about about how this is like focused on the individuals, how the individuals interact with this stuff. Because every individual is going to have their own wallet. Like you could have a corporation that could like own a wallet, that they could have like a bunch of people kind of controlling for the most part. This is just like people on their computers with wallets interacting with this stuff. I think that's pretty cool. Most of these things we're seeing now are similar to what we saw in the last component. We're checking the window and then we're importing our contract address, our abi.

00:37:07 - Anthony Campolo

And then the only difference here is now we have this signer, which we just run a get signer function on the provider. Going back to Ether is giving us really nice APIs to figure this out. Then we're going to have this text area here that's going to do an on change with the message and then it's going to send wavereaction, which is this whole function right here when you actually click the button. Then the only other thing is the wave list.

00:37:46 - Co-host / moderator

We'll look at that once we actually write a message.

00:37:49 - Anthony Campolo

Hopefully this all went according to plan.

00:37:52 - Co-host / moderator

Hello, from.

00:37:58 - Anthony Campolo

This is the step where they're saying, hey, you need to sign this transaction. So your wallet pops up and it says, you need to confirm this transaction. This is the part you tell you to be wary of. This is the part where there's still your stuff. If it's a trend, it's a contract you don't actually want to connect to. So we're going to confirm that and then we're going to sit and wait

00:38:16 - Co-host / moderator

patiently for 15 to 20 seconds

00:38:22 - Jim (host)

while we're waiting. Anthony. So is there some security in knowing, like, when your wallet's popping up? It's providing you details with something that you're like, you essentially can trust, right? Like, your wallet is giving you information that you can trust. So, like, if they're saying in order to complete this, you have to send this amount, is that safe at that point? Or can, like, can that still be misleading where you think you're sending one thing or doing a smaller transaction than you than is reality?

00:38:48 - Anthony Campolo

I guess this is where it's really tricky for people who aren't really coders, because a lot of times when you're being asked to sign a transaction, you can dig in and you can see what the transaction is they're actually asking you to do. And it's giving you this huge JSON blob of methods and stuff. And if you know what those mean, you can go read through it and you'd be like, okay, they said they're gonna give me something, but actually the JSON here says they're gonna take something. So it's not that you can't see what's gonna happen, it's that people are interacting with these things who don't actually know how code works and who don't know how to actually read code. And so what they do is they'll basically have a button that says, like, get a free airdrop. And then they click the button and then you confirm the transaction. But you didn't look at what was the actual transaction because you're just skipping through this menu really quickly. And most people who are using MetaMask, they have no idea what MetaMask is actually doing, you know, so there's like a huge information gap here.

00:39:46 - Anthony Campolo

And this is what makes it so easy to scam people because you can set up a line of like, things to click and messages that make it seem like you know exactly what's going on until the very end when you click that button and realize there's something behind the scenes that they're like, carefully hiding from you that you could have looked at, but you didn't look at because you're following along Interesting.

00:40:05 - Jim (host)

Yeah. So you kind of have to audit it then. So MetaMask isn't providing tons of clarity around that because it seems like since they're authorizing kind of the end transaction there, it'd be nice because it looks like on yours it said you're sending this amount or something like that. Right? Wouldn't that be?

00:40:20 - Anthony Campolo

So let's look at this one more time. So if we take a look at what's happening here. So this is the contract interaction.

00:40:30 - Co-host / moderator

So let's see if that's going to load for us. There's the hexadecimal, which is of course super useful.

00:40:45 - Anthony Campolo

So normally when you're signing a transaction, it should give you more information. I'm not sure why it's not right now. There's also lots of other wallets out there. So there's always kind of like there's at least competition in the space. So if like one wallet is like dropping the ball on security, other wallets can kind of come in.

00:41:06 - Jim (host)

Sure.

00:41:06 - Co-host / moderator

Let me see if I can actually get this to show something. See? Okay, here we go. So this is the transaction. Transaction.

00:41:22 - Anthony Campolo

So this is what we're looking at right now is Etherscan. So this is the blockchain itself, a way to kind of like read it and query it and try and understand it a bit. And so you can go look at

00:41:36 - Co-host / moderator

the contract and then here's the contract and.

00:41:43 - Anthony Campolo

Oh my God, look at that. So it's like you can decompile the contract to look at the code if you're willing to wait like 86 minutes. And this is the exact reason why things like Avalanche exist, because there's no reason why you should have to wait 86 minutes to do something like that, because the Ethereum network has certain bottlenecks in it. So this is where you can see, like if I wanted to go look at this smart contracts code, it's on the blockchain. Like the code is on the blockchain. You can go look at if you want. You can see what the contract is actually doing. But the vast majority of people aren't going to do that. And the vast majority of people are going to just click the button and then hope for the best. And that's why you shouldn't really interact. You shouldn't really put your money into this stuff until you have a clear understanding of how it works. And this is why I recommend people. If you want to invest in crypto and you want to get involved in it, this is not financial advice. But you should start with something Like Coinbase, because Coinbase, they hold your keys for you, which some people say that means you don't owe your, you don't own your money, means Coinbase owns your money.

00:42:39 - Anthony Campolo

It's like, well, yeah, but the bank owns my money too. So there's companies that will allow you to kind of put trust in them to make sure that you are saving yourself from getting owned. Like, if you put your money in Coinbase, you can't click a button and give away all your funds because it's not just sitting in a wallet that you're using and you're interacting with on the Internet. So there's ways to protect your funds. And the main thing is like if you just have money in a MetaMask wallet, then you're always vulnerable to these kind of attacks. These have social engineering type things because anytime you're clicking a button in your MetaMask wallet, you have to have done your research like was actually doing. This is why it's just like if you're going to buy like an NFT or something, like don't buy an NFT in some random project you just like heard about. Like if you've heard of, like, if you can go research it, you can find out who's the team behind it. You can see there's a company behind it. You see there's like individuals putting their name behind it.

00:43:32 - Anthony Campolo

That's usually a good sign if you are seeing something and you go research it and you can't figure out who it is, where the website is, and there's just this random Twitter account with 50,000 followers. That's probably a bot farming kind of of thing.

00:43:44 - Jim (host)

Sure, yeah. Hopefully in the future this stuff gets a little more transparent. I feel like the reality is most people, myself included, are going to just click buttons and don't have time to audit, you know, everybody's code at the end of the day. So hopefully someday that this, this becomes a little more secure to.

00:44:01 - Anthony Campolo

Yeah, I mean, I think the, the services are already there that are, that are secure and that are doing that for you, but it's about knowing who those services are and knowing which ones to trust and which one is not to. So having a Web3 friend is useful.

00:44:13 - Jim (host)

Yeah, for sure.

00:44:16 - Anthony Campolo

Great. That's the application. But this is not a Jamstack application yet though. Obviously we got to put it on Netlifier Vercel or else it's not Jamstack. What's cool though is this whole thing is just a static website right now, quite literally. There's nothing we don't even have to include any environment variables because our contract address is hard coded in. If we want to now deploy this, all you gotta do is run the

00:44:49 - Co-host / moderator

Vercel command and then click through all this.

00:44:54 - Anthony Campolo

And what this is going to do is it's going to just take a project, push it up to Vercel, and Vercel now owns the man who created Svelte. That's kind of like owning Svelte, I guess. So there's nice svelte integrations. Then what this is going to do is it's going to not only deploy our application, but it's going to deploy our application with the messages we've already created, because the contract hasn't changed. The fact that we're interacting with the contract through localhost or through the actual website is irrelevant. That's the decoupled nature coming in here, is that when you deploy a project locally with SQLite and then you spin up a production database, then you redeploy the app, then you're back at zero. But with this, we were already interacting with our back end, even on localhost and we were writing these messages into the blockchain, even from localhost. That's the jamstacky decoupled nature coming in here. Here is our website on. First of all, I don't want this

00:45:59 - Co-host / moderator

on Brave, I want this on on Chrome. Go here, connect. And then there's our message and we're going to say hello from Vercel, the Vercel team. So I gotta connect this first.

00:46:16 - Anthony Campolo

So the Vercel team is pretty into Web3 stuff. There's already a decent amount of Web3 projects that are running, like their front ends and web marketing pages and stuff like that on Vercel. And then you have a lot of dapps that are starting to be built with next JS. Netlify is not down with Web3 though. I know a lot of developer advocates at Web3 and they think it's bad news. So I wouldn't expect Netlify to get involved in Web3 anytime soon, but Vercel is basically already there. All right, someone just do that. Is there, is there a technical reason

00:46:56 - Jim (host)

for that or is it just a difference in community or what's. Can you talk a little bit more about that?

00:47:02 - Anthony Campolo

Yeah, I mean, it's, it's. Yeah, it's definitely a difference in philosophy. I think that, you know, the people who I've talked to at netlify about it, they just think that it's, you know, they don't think that the technology has much promise. They think that's being used for a lot of scams. And they think that, you know, there's, there, there are negative externalities of Web3. And like, I'm not gonna, like, sit here and tell you there's no bad things in Web three. So I think, like, when you have companies that are like, raising these concerns, like, those concerns are valid, you know, and that's totally fine. I think the, the thing you have to do though, is you have to really separate who are the bad actors in this space. And are those bad actors the developers? Or is it people who are coming in and trying to break these systems and steal money from people? Because, like, when people talk about crypto scams and people talk about Web3 Bros. And people talk about all this stuff, they lump it all into the same barrier. But the people scamming People on Web3 are not the people building Web3 applications.

00:47:57 - Anthony Campolo

Those are two separate groups of people. We would love for there to be less people trying to steal everything from Web3. That would be awesome. But the thing that you really got to think about is do you want to give users access to this new world? Because it means that there's going to be higher risk involved, but also means they're going to potentially have a lot of upside in terms of getting involved in this new technology and getting it on the ground floor. And like, people who bought Ethereum, like I bought. So this is a funny story. I bought some ethereum in like 2017 and then ended up like, I had a couple years after that where I had like, no job. It was like, broke off my ass. And so I sold all my crypto. But there were some Ethereum that I forgot about and did not actually sell. And I found Ethereum paper wallet that I had screenshotted just like a couple months ago. And that Ethereum that I probably paid maybe like 1, 2, 3, maybe at most $300 for was worth $10,000 over the course of that five years. Is how much good for you get involved in this stuff in the beginning, you actually might find that you're going to get the types of returns that the startup founders are getting by building these things.

00:49:18 - Anthony Campolo

Because if you're building, you know, like a Supabase or something like that, you're going to get those same returns, but only if you're a founder and only if you're an accredited investor who makes $200,000 a year, has like a certain amount of money. But, like, there's all these legal, like, there's laws based on whether you're allowed to invest in early stage companies like. So for me, this is about actually also giving people access to financial investments and tech innovations that could pay off in the long run. But that also means you have to be responsible for those investments because there's going to be a thousand blockchains and maybe 10 of those are going to still be around a couple of years from now. So you got to do your due diligence, but that due diligence can pay off in a magnitude you can't even imagine.

00:50:06 - Co-host / moderator

And there's our messages.

00:50:10 - Anthony Campolo

Cool. That's the whole demo.

00:50:14 - Jim (host)

This is super cool, Anthony. This is the first time I'm actually really seeing this stuff and I feel like you did a great job of breaking this down and showing all the actual parts that go into getting something like this working. So thank you for walking us through that.

00:50:28 - Anthony Campolo

I also got to shout out Nader Dabit. Nader Dabit was originally leading DevRel at Amplify before leaving to do DevRel at Edge and Node. He's now at a different company. Now he's at Celestia. But about a year ago he wrote kind of like an end-to-end Ethereum tutorial that was fairly similar to what you're seeing here, except with React instead of Svelte. That's cool. And it was one of those things where all of these JavaScript developers all of a sudden realized, oh, you mean you can just do this with JavaScript? That's awesome. And so once you kind of see an end-to-end example where you have a JavaScript app querying a blockchain, then it all becomes way less scary. I can do this, actually. If I can get data back from this blockchain, I can write a front end for it and then I build a dapp. You know, technically it's not a dapp right now because it's on Vercel. So there's two centralized servers here: Vercel is a centralized service and QuickNode is a centralized service. So if you're a Web3 purist, we're cheating in two ways right now.

00:51:29 - Jim (host)

Sure.

00:51:30 - Anthony Campolo

This is something we should talk about real quick: when should you stick with. Thanks for coming, Brittany. When should you stick with the kind of decentralization purism and when should you compromise on using a centralized service because it's worth the benefit you get from using it? So for us and developers who don't know how to run Kubernetes or don't know how to run, you know, like EC2s at scale, running a blockchain node is just way outside of your capabilities. So having the ability to use a service like QuickNode gives you access to the blockchain and it doesn't make Ethereum centralized, like Ethereum is still decentralized. QuickNode owns a bunch of nodes that they're going to give you access to, but nothing has changed here in terms of the actual deal, in terms of the contract. So the decentralized asset is still there even when you're using a centralized service. And then you're putting trust in that centralized service. If you wanted to, you could leave QuickNode at any point in time, keep that entire app exactly the same and change out that one URL I showed you and change it to Alchemy or Infura or one of our competitors and your entire app will run exactly the same because we're just connecting to this blockchain just like everyone else.

00:52:44 - Anthony Campolo

We're not doing anything fancy there for you except running servers on a global scale. Then the front end part is being done by Vercel. That's the centralized service. That's where IPFS comes in. If I want my front end to be on a decentralized, unstoppable protocol, then I'll put on ipfs. But there's all these issues with ipfs. It's super slow, super unreliable. It's like you got all these conventions you got to learn. For me, I think using these node providers and using these front end jamstacks providers allows you to build a Web3 application with almost as little friction as you would building a Web2 application.

00:53:25 - Jim (host)

Yeah, it seems like you need some folks helping smooth out the experience to have on ramps, like these different services just because it is complicated. And I think even at this level, I think people need to understand how these things work. So I think it's great that there's innovation happening in that space. It feels a lot to me kind of like early days of the Internet. Right? So in the, in the beginning people kind of thought the Internet was a fad. It's hard to believe now looking back at that, but you know, you know, people are trying to read their newspapers on it and it was like, ah, I don't know if you can do much more than this and look at it now. So I'm definitely interested to see where the space goes. It seems like there's a lot of promise there. I, I totally get the hesitancy too. I Think you know anything new? There's going to be lots of grifters and you want to make sure that balance is mostly creators and less grifters. And I think people get freaked out by that.

00:54:10 - Anthony Campolo

You shouldn't take people's word for anything in tech. I know people are telling you this thing does this and has all these benefits. The first thing you should say is we'll prove it. So that's true of blockchain, that's true of deployment providers, that's true of open source frameworks. I encourage everyone to be skeptical of every single piece of tech out there. But what's cool about blockchain is once you start digging into it, you're like, oh, this is actually built on 40 years of cryptography research that's like extremely academically rigorous to the point where like it's going to make your brain hurt if you try and actually dig into these protocols.

00:54:43 - Jim (host)

Yeah, no, yeah, it's very, very cool. Do any folks on the call have questions for Anthony? I'd like to open up the floor if you want to ask questions about the demo or web3 in general.

00:54:57 - Anthony Campolo

And thanks for all coming out. Super happy to have an audience here.

00:55:02 - Co-host / moderator

Thank you, Anthony.

00:55:06 - Anthony Campolo

I'll throw out just some links for people. I am on the Twitters as AJC Webdev along with GitHub and you can just go to actually ajcwebdev.com to find my blog as well. I'm putting out Web3 content and then also just general web development content. I'm still very much into like new JavaScript, front end or open source kind of kind of tools. And I'm still hosting fsjam, which we had Jim on, which was super fun way back in the day. Yeah, yeah.

00:55:45 - Co-host / moderator

Thank you for coming.

00:55:47 - Anthony Campolo

And then if you want to check out QuickNode, I only showed you Ethereum, but we have chains. We have 14 chains right now. So if you are interested in kind of expanding out into the other areas of the blockchain world, I think that it does a good job of exposing you to more of them, but not too many of them. So if you go on CoinMarketCap, you're gonna see like 10,000 coins. Well, how do I. Like, they're ranked, but how do I know what to do with these? So just getting to work for a company like QuickNode and see what chains are supported, what goes into having a chain be supported here, it makes me feel more confident in the time and money and energy I put into learning a chain, into interacting with the chains. I can be like, okay, I can see that Avalanche is going to stick around. Like, I feel very, very confident in saying that. Thanks everyone for coming. But you know, the reason why I can say that, or I can say like Solana is going to stick around, is because I'm seeing the back end and I'm seeing what is actually getting adoption, you know, so if you really are interested in this stuff, you're really gonna have to do your research.

00:56:50 - Anthony Campolo

You have to talk to a lot of people. But you'll find people are actually more open to sharing this information than you think.

00:56:59 - Jim (host)

Yeah, that's great.

00:57:01 - Audience questioner

If we wanted to learn to dive in and start learning more about developing for Web3, where would you recommend we look next?

00:57:10 - Anthony Campolo

Yeah, so Patrick Collins.

00:57:14 - Co-host / moderator

I'll post something.

00:57:17 - Anthony Campolo

He is the premier kind of educator in the space right now. He just, within the last month, actually released a 32 hour course on the entire end-to-end getting into Web3 for JavaScript developers. And it's more high quality. You're going to find courses that are going to cost you thousands of dollars. I guarantee you they are not going to be better than his course. Like, his course is going to be the best and it's going to be free. So start with that one.

00:57:49 - Co-host / moderator

Let me see if I can find this.

00:57:51 - Anthony Campolo

And then Nader Dabit has a lot of great stuff as well. He's got a lot of the end-to-end type examples that I've been showing.

00:58:03 - Co-host / moderator

So let me drop his Ethereum if

00:58:06 - Anthony Campolo

you're interested in learning about. And then if you want to like. So what's funny is actually, that example that I used today, I mentioned this before the call, I figured out how to do that from a guide from my own company. So QuickNode had a guide of how to connect a Svelte app to Ethereum. So this is one, like I'm not just hacking my company's product right now. The QuickNode guides are really, really good. They're really well written, they're really thorough. So you can learn a ton just from reading our guides. And then I'm doing weekly live streams. So I've walked through a couple projects kind of like this on the QuickNode YouTube and Twitch account. So if you want to hang out on any of those, I'm going to be putting out content about this stuff for probably many years to come. So I'm very passionate about creating good educational material for this stuff because I think it's still pretty sparse, but there's enough out there for you to get started for sure. You just kind of have to know where to look. So I'd say start with Patrick Collins, start with Nader Dabit, and then check out some QuickNode stuff.

00:59:12 - Anthony Campolo

And that should give you like plenty to work on for the next month or two, you know.

00:59:17 - Audience questioner

That's great. Thank you very much. This was really interesting. And I mean, just really things that I was completely unaware of, really. I mean, thinking of the blockchain essentially as a back end to, to something had never, you know, it's not, not something I'd ever thought about it.

00:59:33 - Anthony Campolo

So, like, blockchain, the most poorly explained piece of technology ever, I think.

00:59:41 - Audience questioner

Yeah, so, no, that's, that's, that's really great. I really want to do some research and learn some more about it because it looks like, you know, a really fascinating emerging technology.

00:59:51 - Anthony Campolo

Yeah, I mean, it's going to, it's going to stretch your, your mind muscles to kind of like learn it, which I think is really cool. You know, it's always nice to have like, you know, expand as developer, like, what's actually possible to do with these things. And I would also say, like, anyone out there wants like, you know, DM me, ask questions, looking for more resources. Like, I'm always available. Like, this is kind of my job as a devrel person is to, to be out there talking to the, the people kissing babies and all that stuff. So always happy to, to, you know, help anyone out who's looking to do this. If you want to get a job in web 3, I can help you out with that too. Well,

01:00:25 - Audience questioner

I've already brought up your LinkedIn page to connect you.

01:00:28 - Anthony Campolo

So, yeah, I would say I've heard that senior Solana developers are currently making around a million dollars a year.

01:00:36 - Jim (host)

Okay, I'll take one of those.

01:00:38 - Anthony Campolo

Exactly

01:00:42 - Jim (host)

that. So, yeah, you're out there kissing the crypto babies, Anthony. That's all day, every day.

01:00:47 - Anthony Campolo

I mean, it's like, it's a combination like you gotta, you got to punch people on Twitter and then kiss the baby.

01:00:51 - Jim (host)

Yeah, that's a good punching by day, kissing baby by night. That's great. I guess. I had a quick question about just like, it seems like the financial service industry with cryptocurrencies and stuff has kind of been the first testing ground for blockchain technology. What do you think the next industry is going to be in this space? Because there's obviously now There's a whole open source developer community working on this. Do you see certain apps being built or certain organizations adopting this technology? Do you have any predictions about where this might go next?

01:01:24 - Anthony Campolo

Yeah, the really big unlock is going to be if we can get a crypto social network created. Because all the stuff that we've been kind of showing as I've been talking about, there's been things with like identity and ownership and stuff like that and control over how the thing works. So that's really, really useful for social app. If you think about it like no one can. Like there was this big question when Elon Musk was talking about buying Twitter. People like, is Elon Musk going to open source the Twitter algorithm? You can't close source a blockchain algorithm. If you wrote Twitter on a blockchain, it would be open source by default. So that's really cool. And there's something called the Lens protocol, which is the first kind of version of this that is starting to pick up. So. So I would definitely point people to this. I think this is super, super interesting. And then I've talked about this a couple times already, which is ipfs. And then there's another one called Arweave which are about how do you create permanence for not just these transactions but for like websites and for the Internet itself.

01:02:30 - Anthony Campolo

And so I think that's going to be really cool. And then you're also seeing there's already jamstack versions of this. This, there's a company called Fleek, which is basically, we'll build a jamstack site on your IPFS for you. So all that stuff I think is super interesting. Actually, while I'm dropping all these links

01:02:49 - Co-host / moderator

I should drop, I have an IPFS blog post.

01:02:54 - Jim (host)

So again, I want to, you know, at some point, I know folks gotta hop off and I want to be respectful of people's time, but IPFs, how does this work? Is there like a centralized organization? Kind of like the same way that we dole out IP addresses. Thinking about this stuff or is there a company behind it? How does this stuff work?

01:03:13 - Anthony Campolo

There's a lab behind it. So have you ever heard of Bell Labs?

01:03:17 - Jim (host)

Yeah.

01:03:18 - Anthony Campolo

So Protocol Labs is behind IPFs and they're modeled on Bell Labs actually. They see themselves as a research lab that's funded as a company also. And so they are the ones who have been pushing ipfs. And there's a blockchain called filecoin that is about creating a tokenized incentivization structure to basically pay people to store things on their computer. And that was the largest ICO in the bubble from like 2017 to 2018. And so they survived even though they got this crazy valuation that no one knew what to do with. But that is a lot of stuff is really interesting wrapped up in that because that has to do with. Just think about link rot on the Internet. How many times do links just go dead? A link can't go dead. Well, technically IPMS garbage collects itself, so that's some kind of an asterisk. But for the most part if you pin something, a link will be on IPFS forever. And that's really cool if you want to guarantee your website is always giving going to be up. And companies like Cloudflare already provide gateways to interact with IPFs. So there's already web two companies that have built infrastructure to work with IPFs.

01:04:33 - Anthony Campolo

It's just super, super janky and does not work very well. So it's fun to play around with. But like I would never host my actual own personal site on ipfs, but I probably would on Fleek because Fleek is a centralized service that's making IPFS a lot nicer. So this is about, there's, there's always these trade offs of the decentralized stuff is usually going to be a little janky. But there may be a centralized service that's going to make interacting with that decentralized thing really, really nice. So yeah, Fleek is in the same mold as like Quick Node in that respect.

01:05:02 - Jim (host)

And also I imagine, you know, standardized browsers have to build capabilities as well. I know like Brave for instance, interacts with like unstoppable domains and things like that. But I assume that browsers have to

01:05:15 - Anthony Campolo

like kind of like I have an unstoppable domain.

01:05:17 - Jim (host)

Okay, yeah, yeah, I assume that eventually the whole ecosystem has to come on. This will probably take some time to make it make sense.

01:05:24 - Anthony Campolo

Right. Right now there's hacks. Basically what you do is you write a DNS record that takes a text record and points it to a content hash on ipfs. So there's ways you can link up DNS and ipfs. It just takes a little bit of knowledge of DNS itself. But this is the stuff like over the next couple of years that's all going to get ironed out and people are going to just be buying domains that are actually crypto domains and they're not going to really be able to tell the difference.

01:05:53 - Jim (host)

Sounds cool. I'm excited for it. Okay. I think that this is probably a good breaking point. Unless other Folks have dire questions they want to ask before we end.

01:06:02 - Anthony Campolo

Great questions. That was super fun. I'm always glad people are actually interested in this stuff because I came from the Web2world and I've been going through, have my network of people and be like, hey, you want to talk about this? You want to talk about that? Like, some people are like, cool, that sounds interesting. Some people are like, nah, man, I want to talk about Web3. I don't want to talk about Web3 stuff, you know, so I'm just, I just hope that people can stay open minded about it, you know, and like, you know, like I say, like, I'm not saying it's all good stuff. Like, I will, I will. Like there is Terra, there is this blockchain that lost $40 billion in the span of like three days. Like, that's a bad thing. I'll happily call that out, you know, but that's not the whole industry.

01:06:39 - Jim (host)

Yeah. Well, Anthony, thank you so much for coming on and talking to the group. Really appreciate it. I thought the talk was great and fielding the questions was really helpful. So thank you so much.

01:06:48 - Anthony Campolo

Awesome. Yeah, happy to be here. Hopefully we can do another one sometime. All right, great.