Sono uno studente di freeCodeCamp. Ho imparato a programmare su freeCodeCamp. Ho usato queste skill per creare una società di successo.

Oggi, questa società – KaijuKingz – sta donando un milione di dollari a freeCodeCamp per aiutarli e creare ancora più risorse gratuite.

La comunità di freeCodeCamp ha aiutato me e migliaia di altre persone a imparare a programmare creando progetti. Per preparare la scena per la nostra donazione, vorrei dare un po' di contesto sul mio percorso da sviluppatore, a partire da quando ho trovato per caso freeCodeCamp a quando sono entrato in Web3.

Questa è la mia storia

Da smanettone a lasciare il college

Ero interessato nella programmazione fin dalla tenera età. Durante le superiori creavo semplici giochi IF-ELSE di avventura testuale per la mia ragazza. Immagino che nella mia mente fossi una sorta di leet developer.

Sfortunatamente, la mia scuola a quel tempo non offriva percorsi per esplorare la programmazione. Nonostante ciò ho fatto del mio meglio per accrescere le mie abilità. Ero molto coinvolto in un corso su computer system che permetteva di ottenere certificazioni come CompTIA, A+, e Net+.

Quando poi ero stato in grado di andare al college, decisi di studiare Computer Science, ma rimasi indietro piuttosto in fretta. I libri costavano troppo, c'era una mancanza di risorse in generale. Alla fine ho lasciato il college.

Dopo aver combattuto con la motivazione, ed essere stato senzatetto per un po', mi impegnai a rimettere la mia vita in ordine.

La risalita

Sono stato in grado di usare la certificazione CompTIA per ottenere il mio primo lavoro a salario minimo come tecnico dei computer ad un grosso rivenditore. Andai sempre più a fondo nel campo, e lavorai verso la cima con sforzo consistente.

Sono riuscito ad arrivare al ruolo di supporto di livello 2 nel dipartimento informatico di un grosso centro salute. Qui è dove ho riscoperto il mio amore per la programmazione e iniziai a automatizzare priccole attività. Ho iniziato a scrivere script in Visual Basic. PowerShell era diventato il mio strumento preferito per automatizzare le attività. Pezzettino a pezzettino, crescevo nel campo.

Questo è il punto in cui ho considerato per la prima volta imparare per diventare uno sviluppatore full-stack. Cercavo strumenti e sognavo il giorno in cui avrei potuto frequentare un bootcamp di programmazione e diventare un super fantastico sviluppatore full stack.

Questo è il punto in cui ho scoperto per la prima volta risorse gratuite come freeCodeCamp e i tanti canali YouTube che insegnano a programmare. (Menzione speciale per Sentdex <3).

Nel 2019 ho completato la certificazione del corso di Web Design Responsivo di freeCodeCamp. E continuavo a controllare freeCodeCamp per leggere i nuovi tutorial r guardare nuovi corsi video che la comunità crea ogni giorno. Era divertente, stavo imparando un sacco, e non mi stava costando un centesimo.

Dal mio primo lavoro in Software Engineering a iniziare la mia prima società

Ho ottenuto il mio primo lavoro in software engineering in 2020 per una piattaforma di eCommerce. Ho continuato a migliorare le mie abilità.

Salto temporale a sei mesi fa: ho decisp di dedicare tutto il mio tempo a imparare lo spazio Web3, con un focus su decentralizzazione e creazione di una comunità. Il risultato: KaijuKingz.

Quando abbiamo creato KaijuKingz, il mio team ha deciso di mettere da parte dei fondi per aiutare altri aspiranti sviluppatori e creatore a imparare Web3. Avevamo pianificato di mettere da parte abbastanza soldi per mangare 3-4 a un bootcamp per programmare, magari cambiare la vita a qualcuno, e fine.

Dopo il nostro successo, abbiamo realizzato che avevamo l'opportunità di influenzare le vite di più persone di quante avessimo inizialmente pianificato. Quindi ci siamo rivolti a Quincy per discutere come potessimo usare i nostri fondi per creare un programma Web3 per aspiranti sviluppatori. Volevamo aiutare persone che sono appassionate degli argomenti di decentralizzazione e tecnologie possedute dalla comunità.

Abbiamo deciso di mettere tutto in campo con questo team e la loro storia di sviluppare corsi efficaci e certificazioni accessibili da chiunque nel mondo.

Piani per il futuro Curriculum Web3 su freeCodeCamp

La nostra donazione da un milione di dollari andrà verso la creazione di un intero curriculum sullo sviluppo Web3. Coprirà tutto dalle basi della programmazione con Rust e Solidity, a usare librerie JavaScript come web3.js.

Questo curriculum provvederà alla fine circa 300 ore di apprendimento gratuito per aiutare le persone  ad andare da zero to hero con Web3. L'unica cosa di cui gli studenti avranno bisogno è accesso ad un computer e la disciplina di completare il curriculum. L'esistente curriculum Web2 ti insegnerà tutti i prerequisiti necessari.

Sia io che Quincy teniamo molto all'ambiente, e questo curriculum sarà carbon-neutral.

Ho fondamentalmente cambiato la mia vita imparando a programmare attraverso risorse gratuite. Restituire a una delle più complete ed efficaci risorse gratuite per imparare a programmare (e anche aiutando ad aggiornare il loro curriculum per il futuro) mi ha dato un proposito. Invece di cambiare la vita di una persona, speriamo di cambiare la vita di migliaia di persone e di portare nuovi sviluppatori all'ecosistema Web3.

Grazie a freeCodeCamp, alla comunità KaijuKingz che ci ha supportato, e a tutti coloro che stanno aiutando a costruire un futuro decentralizzato.

Saluti,
Nathan

Se sei appassionato di tecnologia, ci sono buone possibilità che tu abbia sentito i termini Bitcoin, Crypto, Ethereum o anche "registri distribuiti e decentralizzati".

Probabilmente hai sentito parlare di criptovaluta e algoritmi di crittografia, della fine degli "intermediari" e così via.

Comunemente si è portati a pensare che le criptovalute (es: Bitcoin, Ripple, Ethereum, Litecoin, ecc.) e la Blockchain siano la stessa cosa. Ma non così.

Le criptovalute sono un'applicazione intelligente di una tecnologia molto più intelligente: la Blockchain .

In questo post tratterò alcuni dei concetti di base della Blockchain in modo da capire di cosa si tratta, come deve essere concettualizzata e cosa si può costruire su di essa.

Ma come per tutte le cose, ha più senso se capisci perché sono state inventate, prima di entrare in quello che fanno. In questo modo ti sarà più facile capire per quale problema da risolvere è stata progettata la blockchain.

Perché usare blockchain?

Ottima domanda. Sono così felice che tu l'abbia chiesto. Sediamoci e facciamo un piccolo esperimento mentale.

Cosa succede se tu e il tuo migliore amico conducete indipendentemente e separatamente la stessa campagna di petizioni? Diciamo che è per la causa "Liberate i criceti".

Diciamo che la conduci rispettando una sequenza identica al tuo amico e nello stesso sobborgo, ma tiri fuori un diverso numero di adesioni alla petizione. Quale versione della petizione firmata è la “fonte di verità”?

Dovresti risalire lungo i due elenchi di firme, una firma alla volta, per individuare l'ultima discrepanza. E poi dovresti lavorare più indietro per identificare il primo risultato che diverge tra le due liste. Prima di tale punto di origine della divergenza, tutte le altre firme nei due elenchi dovrebbero corrispondere.

Quindi una cosa è sicura. Prima di questo punto di divergenza, entrambe le liste sono in accordo, quindi quelle firme rappresentano il numero minimo di persone che hanno firmato per sostenere la liberazione dei criceti.

Sebbene possa funzionare bene per criceti e piccoli sondaggi suburbani, non funziona così bene nel mondo digitale. Oppure votazioni, operazioni bancarie, transazioni finanziarie, trasferimento di proprietà fondiarie, adempimento di obblighi contrattuali, ecc. Sono necessarie "terze parti di fiducia" indipendenti per verificare una catena di eventi e rassicurarti solennemente che la "catena di custodia" non è stata interrotta.

Una "catena di custodia" a volte può anche essere chiamata "provenienza" - entrambe significano la stessa cosa: la sequenza di eventi storici relativi ai dati in questione.

Ecco perché ci sono governi che hanno l'ultima parola sulla tua identità, e i voti devono essere contati fisicamente e ricontati da centinaia di volontari, e gli impiegati in uffici squallidi tengono registri e certificati per confermare se possiedi o meno la tua fattoria o la staccionata bianca del bungalow.

Ecco perché hai bisogno di intermediari finanziari per assicurarti che quando acquisti il tuo pupazzo da collezione di Darth Vader, utilizzando una carta di credito, il denaro (valore) venga "rimosso" dal tuo account e "immesso" sul conto del venditore.

Questo è tecnicamente chiamato il "problema della doppia spesa": come ci si assicura di non spendere gli stessi soldi due volte? Senza qualcuno che lo faccia, potresti spendere i soldi e allo stesso tempo continuare a possedere quei soldi stessi.

Quindi è davvero un grosso problema: la vita moderna richiede che ci affidiamo, ci fidiamo e paghiamo intermediari di terze parti "fidati" per garantire che il valore (il denaro) effettivamente "passi di mano" digitalmente. Ecco perché esistono Visa e MasterCard e perché PayPal e altri si collegano ai tuoi conti bancari.

Al centro del perché della Blockchain c'è questo problema: come fai a sapere che una sequenza di eventi non è stata manomessa per alterare lo stato attuale?

È qui che si inserisce la Blockchain. Chiaro finora?

Come funziona Blockchain

Allo scopo di comunicare un concetto con semplicità, posso prendermi delle libertà con alcuni degli aspetti tecnici e nascosti di questa tecnologia. Il mio obiettivo è farti capire di cosa si tratta e avere un modello mentale di come funziona. Per questo, potrei aver bisogno di essere un po' sciolto con la precisione al fine di migliorare le probabilità di comprensione, specialmente per i non madrelingua.

Per la precisione, è essenziale ricordare che la Blockchain è una tecnologia, un codice software matematicamente complesso. E Bitcoin (o Ethereum o qualsiasi altra criptovaluta offerta) sono solo applicazioni di questa tecnologia.

Quindi i principi chiave sono:

• Le blockchain vengono "estratte" (prodotte attraverso il dispendio di sforzi, come nell'estrazione dell'oro) da computer potenti e affamati di risorse – chiamati nodi, che si trovano sulla stessa rete.
• Catene di registrazioni di transazioni crittografate digitalmente e con timestamp sono raggruppate in "blocchi", che vengono mantenuti su un "registro" da ciascun nodo. Quando le transazioni vengono aggiunte a un blocco, i blocchi vengono collegati tra loro in modo lineare e cronologico come "catene". Quindi l'intero record/registro viene sincronizzato attraverso la rete di nodi in modo tale che tutte le "catene" di blocchi sui nodi dovrebbero raccontare la stessa identica cosa circa l'iter di una determinata transazione. Quindi otteniamo "blocco + catena = blockchain". È una lunga e complicata lista concatenata.
• Ogni blocco in una catena ha il proprio ID, un hash crittografico unico e specifico per ogni blocco. Quell'hash viene anche memorizzato nel blocco successivo della catena, causando un collegamento. Un blocco può memorizzare migliaia di transazioni e la più piccola modifica ai dati di quel blocco risulterebbe in un nuovo hash. Quindi, se un hash cambia ma il blocco successivo ha un hash diverso, sappiamo che alcuni dati nel blocco precedente sono stati manomessi.
• Man mano che centinaia diventano migliaia di nodi (e ne vengono aggiunti altri continuamente), ogni nodo deve "concordare" sulla cronologia dei blocchi/registro – questo è chiamato "consenso critico". Uno dei modi in cui si ottiene il consenso è attraverso l'hash crittografico di cui abbiamo parlato prima.
• In caso di discrepanze nel registro (ad esempio l'hash di un blocco non corrisponde al riferimento del blocco successivo all'hash del blocco precedente), il registro con la catena più lunga di transazioni valide incorporate sarà quello “corretto” – la fonte di verità. Eventuali nodi che lavorano su altri nodi (versioni più corte) della catena passano a quella più lunga. Ciò mantiene il consenso critico (questo concetto è estremamente semplificato, ma per ora sufficiente).
• Qualsiasi intercettazione o modifica malevola di un registro (di nuovo, ad esempio, quando l'hash di un blocco non corrisponde) creerebbe immediatamente una discrepanza con tutte le altre versioni. Avrebbe anche una "storia" di blocco più breve a confermarlo, il che rende quella versione manomessa un elemento sospetto nella rete blockchain dove la lunghezza conta (ehm).
• Replicare quella discrepanza su tutte le versioni registro - l'intera rete blockchain - è un compito così enorme che è poco pratico dal punto di vista computazionale e accadrebbe solo se i malintenzionati avessero improvvisamente il controllo sulla maggior parte dei nodi che estraggono blockchain e li cambiassero tutti piuttosto rapidamente. Questo tipo di attacco coordinato alla maggior parte dei nodi della rete è spesso chiamato attacco del 51% .

È interessante notare che Satoshi Nakamoto afferma nel white paper originale di Bitcoin ,

“ In quanto tale, la verifica è affidabile fintanto che i nodi onesti controllano la rete, ma è più vulnerabile se la rete è sopraffatta da un utente malintenzionato. "

Tuttavia, altrove lui/lei/l'organizzazione (non sappiamo chi sia "Satoshi") sottolinea con calma che modificare le passate transazioni nei blocchi, sull'intera rete di nodi, richiederebbe all'attaccante di rifare la catena di custodia in quei blocchi, e tutti i blocchi aggiunti dopo. Quindi dovrebbe correre come un pazzo per raggiungere e superare il lavoro dei nodi che non sono sotto il suo controllo (in modo che possa riscrivere il registro, per così dire).

E per questo motivo, la "probabilità che un attaccante lento recuperi il ritardo, diminuisce esponenzialmente man mano che vengono aggiunti blocchi successivi".

L'assoluta complessità programmatica, il ritmo e il volume delle attività nodali rendono difficile per i falsari/attaccanti recuperare il ritardo, per non parlare di superare i nuovi blocchi costantemente estratti.

Questo ha senso. È come la bugia che dici a un membro della famiglia sul motivo per cui non hai potuto partecipare al saggio di flauto dei loro figli. E poi devi inseguire pazzamente tutti gli altri membri della famiglia e assicurarti di aver detto loro la stessa bugia in modo che quando la persona interessata a cui hai mentito tira fuori l'argomento, tutti siano consapevoli di questa bugia e tengano il tuo gioco. Sembra estenuante.

Per concludere, la caratteristica distintiva di una blockchain è che è un registro distribuito su molti, molti nodi ed è estremamente intensivo dal punto di vista computazionale (costoso) aggiungere nodi a quella rete.

Pertanto, ogni registro deve essere "consapevole" di tutte le transazioni e deve avere una versione concordata (che avrà la "catena di custodia" più lunga dietro di sé) attraverso l'intera rete a cui verrà aggiunta la transazione successiva.

Come dichiara Satoshi Nakamoto nel white paper originale di Bitcoin, "L'unico modo per confermare l'assenza di una transazione è essere a conoscenza di tutte le transazioni."

È importante sottolineare che la blockchain "dis-intermediata" è fidata, quindi non dobbiamo pagare commissioni di transazione a "terze parti fidate" per essere affidabili e mantenerci onesti noi e le controparti con cui trattiamo . La blockchain garantisce in modo programmatico la verità (provenienza) della cronologia delle transazioni in essa contenute.

Allora perché dovremmo preoccuparci?

Ebbene, eliminando la necessità di “intermediari di fiducia” qualsiasi intermediario che fa pagare un compenso modesto per averci dato il dono della certezza ha bisogno di trovare un nuovo lavoro. E questo ha un impatto sulle banche che tradizionalmente offrono tali servizi assicurativi.

Significa anche che possiamo programmare "contratti intelligenti" tra il promittente e il promesso che si accorgono automaticamente (digitalmente) se quella promessa è stata mantenuta o meno.

Ciò ha consentito a un'artista davvero esperta di tecnologia come Imogen Heap di vendere la sua musica direttamente al suo pubblico di ascolto e di riscuotere le sue quote direttamente da loro piuttosto che perdere la maggior parte dei guadagni per etichette discografiche, manager e altri "intermediari di fiducia".

Probabilmente cambierà il modo in cui la proprietà intellettuale sarà protetta, accessibile, condivisa, distribuita e sviluppata su Internet.

Potrebbe anche significare che la flotta di conducenti di Uber effettua transazioni direttamente con le persone che desiderano un passaggio piuttosto che affidarsi a Uber per coordinare e controllare il flusso di informazioni e denaro.

Potrebbe significare che potrei inviarti direttamente piccole somme di denaro praticamente senza commissioni (microtransazioni). Potrebbe significare che i milioni di persone senza banca nel mondo che hanno uno smartphone possono iniziare a effettuare transazioni ben oltre i loro tradizionali confini del mondo fisico.

In modo sorprendente, i governi stanno guardando oltre la semplice criptovaluta pensando al modo con cui implementare questa tecnologia , ad esempio per registrare la proprietà terriera .

In effetti, potremmo creare un mondo di vere transazioni digitali peer-to-peer per il trasferimento di valore che sia distribuito, orizzontale, rimuova la necessità di fare affidamento sulla fiducia e soprattutto richieda una straordinaria potenza di calcolo per manometterlo. Queste transazioni potrebbero essere tra persone, macchine e dispositivi.

Potrebbe quindi offrire un nuovo paradigma di sicurezza per la protezione dei dati raccolti e trasferiti attraverso "l'internet delle cose".

Personalmente credo che la complessità del mondo moderno sia oscurata dietro i touchscreen intuitivi. La tecnologia blockchain sarà rapidamente integrata nel nostro universo tecnologico senza che noi ne saremo pienamente consapevoli, proprio come utilizziamo il DNA ricombinante del lievito per la produzione di insulina sintetica dagli anni '70.

I cambiamenti e i risparmi sui costi saranno ampiamente definiti cambiamenti tecnologici, come quella "cosa interweby" o qualche altra frase vaga e all-inclusive.

Un problema: funzionerà finché possiamo confidare che un "sistema senza fiducia" codificato e progettato dagli esseri umani (di chi ci fidiamo?) promuoverà la causa di processi senza-fiducia in un mondo diffidente e inaffidabile . Potrebbe essere necessario leggere questa frase più volte.

Ricapitolando

OK – ora dovresti essere ragionevolmente consapevole delle basi della blockchain. Ma se sei interessato c'è molto altro da imparare.

Puoi discutere se la blockchain sia utile o troppo pubblicizzata, rivoluzionaria o noiosa. Ma è difficile ignorare che è piuttosto interessante come concetto.

Ecco un video davvero fantastico di Anders Brownworth che spiega il tutto con un modello blockchain. Consiglio vivamente di guardarlo.

E come esercizio di apprendimento, puoi costruire la tua blockchain direttamente nel tuo browser o nella tua riga di comando. Ecco un breve tutorial su come costruire la tua blockchain.

Se hai commenti su questo articolo o pensi che avrei potuto spiegare meglio alcune parti di questo, twittami su @ZubinPratap

Se vuoi saperne di più sul mio viaggio nel codice, dai un'occhiata all'episodio 53 del podcast freeCodeCamp , dove Quincy (fondatore di freeCodeCamp) e io condividiamo le nostre esperienze come cambi di carriera che potrebbero aiutarti nel tuo viaggio. Puoi anche accedere al podcast su iTunes , Stitcher e Spotify.

Terrò anche alcuni AMA e webinar nei prossimi mesi. Se questo ti interessa, per favore fatemelo sapere andando qui . E, naturalmente, puoi anche twittarmi su @ZubinPratap .

In questo articolo imparerai come creare dApp full stack con React, Ethers.js, Solidity e Hardhat.

Puoi trovare il codice per questo progetto qui . Il video corso per questo tutorial è qui.

Di recente mi sono unito a Edge & Node come Developer Relations Engineer e ho approfondito lo sviluppo di contratti intelligenti con Ethereum. Ho scelto quello che penso sia lo stack migliore per la creazione di dApp full stack con Solidity:

• Client Framework – React
• Ambiente di sviluppo Ethereum – Hardhat
• Libreria Web client di Ethereum – Ethers.js
• Livello API: Il protocollo Graph

Però mi sono imbattuto in un problema mentre cercavo di capire tutto questo. Sebbene sia disponibile individualmente una documentazione abbastanza buona per ciascuno di questi strumenti, non c'è molto che ti aiuti a metterli tutti insieme e capire come funzionano tra loro.

Ci sono alcuni standard davvero buoni là fuori come scaffold-eth (che include anche Ethers, Hardhat e The Graph), ma potrebbero essere troppo da comprendere per le persone che hanno appena iniziato.

Volevo una guida end-to-end che mi mostrasse come creare app Ethereum full stack utilizzando le risorse, le librerie e gli strumenti più aggiornati.

Ecco cosa mi interessava:

1. Come creare, distribuire e testare smart contract Ethereum su local, test e mainnet
2. Come spostarsi tra ambienti/reti locali, di test e di produzione
3. Come connettersi e interagire con i contratti utilizzando vari ambienti da un front-end come React, Vue, Svelte o Angular

Dopo aver passato un po' di tempo a capire tutto questo, sono finalmente riuscito a usare lo stack di cui mi sentivo davvero a mio agio. Quindi ho pensato che sarebbe stato bello scrivere come costruire e testare un'app Ethereum full stack usando questo stack.

Spero che questa guida sia utile non solo per altre persone là fuori che potrebbero essere interessate a questo stack, ma anche per me stesso come riferimento futuro. Questo è quel riferimento.

La tecnologia che useremo

Esaminiamo i pezzi principali che utilizzeremo e come si inseriscono nell'insieme.

1. Ambiente di sviluppo di Ethereum

Quando crei contratti intelligenti, avrai bisogno di un modo per distribuire i tuoi contratti, eseguire test ed eseguire il debug del codice Solidity senza dover gestire ambienti live.

Avrai anche bisogno di un modo per compilare il tuo codice Solidity in codice che può essere eseguito in un'applicazione lato client, nel nostro caso, un'app React. Impareremo di più su come questo funziona un più avanti.

Hardhat è un ambiente di sviluppo Ethereum e un framework progettato per lo sviluppo full stack, ed è il framework che userò per questo tutorial.

Altri strumenti simili nell'ecosistema sono Ganache e Truffle .

2. Libreria Web client di Ethereum

Nella nostra app React, avremo bisogno di un modo per interagire con gli smart contract che sono stati implementati. Avremo bisogno di un modo per leggere i dati e inviare nuove transazioni.

ethers.js mira ad essere una libreria completa e compatta per interagire con Ethereum Blockchain e il suo ecosistema da applicazioni JavaScript lato client come React, Vue, Angular o Svelte. È la libreria che useremo.

Un'altra opzione popolare nell'ecosistema è web3.js

3. Metamask

Metamask ti aiuta a gestire la gestione dell'account e a connettere l'utente corrente alla blockchain. MetaMask consente agli utenti di gestire i propri account e chiavi in ​​diversi modi isolandoli dal contesto del sito.

Una volta che un utente ha connesso il proprio portafoglio MetaMask, tu come sviluppatore puoi interagire con l'API Ethereum disponibile a livello globale (window.ethereum) che identifica gli utenti di browser compatibili con web3 (come gli utenti MetaMask). Ogni volta che richiedi una firma di transazione, MetaMask la richiederà all'utente in modo comprensibile.

4. React

React è una libreria JavaScript front-end per la creazione di applicazioni Web, interfacce utente e componenti dell'interfaccia utente. È gestito da Facebook e da molti sviluppatori e aziende individuali.

React e il suo ampio ecosistema di metaframework come Next.js, Gatsby, Redwood, Blitz.js e altri abilitano tutti i tipi di target di distribuzione inclusi SPA tradizionali, generatori di siti statici, rendering lato server e una combinazione di tutti e tre.

React continua apparentemente a dominare lo spazio front-end e penso che continuerà a farlo nel prossimo futuro e forse anche oltre.

5. The Graph

Per la maggior parte delle app basate su blockchain come Ethereum, è difficile e dispendioso in termini di tempo leggere i dati direttamente dalla chain. Quindi in passato vedevi persone e aziende costruire il proprio server di indicizzazione centralizzato e servire le richieste API da questi server. Ciò richiede molte risorse ingegneristiche e hardware e interrompe le proprietà di sicurezza richieste per la decentralizzazione.

The Graph è un protocollo di indicizzazione per interrogare i dati blockchain, che ti consente di creare applicazioni completamente decentralizzate. Risolve questo problema esponendo un ricco livello di query GraphQL che le app possono utilizzare.

In questa guida non creeremo un sottografo per la nostra app, ma lo faremo in un tutorial futuro.

Cosa costruiremo

In questo tutorial creeremo, implementeremo e ci collegheremo a un paio di contratti intelligenti di base:

1. Un contratto per la creazione e l'aggiornamento di un messaggio sulla blockchain di Ethereum
2. Un contratto per il conio di token, che consente al proprietario del contratto di inviare token ad altri e di leggere i saldi dei token e consente ai proprietari dei nuovi token di inviarli anche ad altri.

Realizzeremo anche un front-end React che consentirà a un utente di:

1. Leggere il saluto dal contratto distribuito sulla blockchain
2. Aggiornare il saluto
3. Inviare i token appena coniati dal loro indirizzo a un altro indirizzo
4. Una volta che qualcuno ha ricevuto i token, consentire loro di inviare i propri token anche a qualcun altro
5. Leggere il saldo del token dal contratto distribuito sulla blockchain

Prerequisiti

1. Node.js installato sul tuo computer locale
2. Estensione MetaMask Chrome installata nel tuo browser

Non è necessario possedere alcun Ethereum per questa guida poiché utilizzeremo Ether falso/test su una rete di test per l'intero tutorial.

Come iniziare con create-react-app

Per iniziare, creeremo una nuova applicazione React:

npx create-react-app react-dapp

Quindi, passa alla nuova directory e installa ethers.js e  hardhat utilizzando NPM o Yarn :

npm install ethers hardhat @nomiclabs/hardhat-waffle ethereum-waffle chai @nomiclabs/hardhat-ethers

Come installare e configurare un ambiente di sviluppo Ethereum

Quindi, inizializza un nuovo ambiente di sviluppo Ethereum con Hardhat:

npx hardhat

? What do you want to do? Create a sample project
? Hardhat project root: <Choose default path>

Ora dovresti vedere i seguenti file e cartelle creati per te nella tua directory principale:

• hardhat.config.js – L'intera configurazione di Hardhat (ovvero la configurazione, i plug-in e le attività personalizzate) è contenuta in questo file.
• scripts – Una cartella contenente uno script denominato sample-script.js che distribuirà il tuo smart contract una volta eseguito
• test – Una cartella contenente uno script di test di esempio
• contracts : una cartella contenente uno smart contract di Ethereum di esempio

A causa di un problema di configurazione di MetaMask , dobbiamo aggiornare l'ID della catena sulla nostra configurazione di HardHat in modo che sia 1337 . Abbiamo anche bisogno di aggiornare la posizione della cartella artifacts per i nostri contratti compilati in modo che siano nella directory src della nostra app React.

Per effettuare questi aggiornamenti, apri hardhat.config.js e aggiorna il file module.exports in modo che assomigli a questo:

module.exports = {
  solidity: "0.8.3",
  paths: {
    artifacts: './src/artifacts',
  },
  networks: {
    hardhat: {
      chainId: 1337
    }
  }
};

Il nostro smart contract

Quindi, diamo un'occhiata al contratto di esempio che abbiamo in contract/Greeter.sol :

//SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;

import "hardhat/console.sol";


contract Greeter {
  string greeting;

  constructor(string memory _greeting) {
    console.log("Deploying a Greeter with greeting:", _greeting);
    greeting = _greeting;
  }

  function greet() public view returns (string memory) {
    return greeting;
  }

  function setGreeting(string memory _greeting) public {
    console.log("Changing greeting from '%s' to '%s'", greeting, _greeting);
    greeting = _greeting;
  }
}

Questo è un contratto intelligente molto semplice. Quando viene distribuito, imposta una variabile Greeting ed espone una funzione (greet) che può essere chiamata per restituire il saluto.

Espone inoltre una funzione che consente a un utente di aggiornare il saluto (setGreeting). Una volta distribuiti sulla blockchain di Ethereum, questi metodi saranno disponibili per l'interazione di un utente.

Apportiamo una piccola modifica allo smart contract. Poiché impostiamo la versione di solidity del nostro compilatore su 0.8.3 in hardhat.config.js, assicuriamoci anche di aggiornare il nostro contratto per utilizzare la stessa versione di solidity:

// contracts/Greeter.sol
pragma solidity ^0.8.3;

Come leggere e scrivere sulla blockchain di Ethereum

Esistono due modi per interagire con uno smart contract: lettura o scrittura delle transazioni. Nel nostro contratto, greet può essere considerato transazione in lettura e setGreeting può essere considerato transazione in scrittura.

Quando si scrive o si inizializza una transazione, è necessario pagare affinché la transazione venga scritta sulla blockchain. Per farlo funzionare, devi pagare il gas che è la commissione o il prezzo richiesto per condurre con successo una transazione ed eseguire un contratto sulla blockchain di Ethereum.

Finché stai solo leggendo dalla blockchain e non modifichi o aggiorni nulla, non è necessario effettuare una transazione e non ci saranno gas o costi per farlo. La funzione che chiami viene poi svolta solo dal nodo a cui sei connesso, quindi non devi pagare alcun gas e la lettura è gratuita.

Dalla nostra app React, interagiremo con lo smart contract utilizzando una combinazione della libreria  ethers.js, indirizzo del contratto e ABI che verrà creato dal contratto da Hardhat.

Che cos'è un ABI? ABI sta per interfaccia binaria dell'applicazione. Puoi pensarla come l'interfaccia tra la tua applicazione lato client e la blockchain di Ethereum in cui viene distribuito lo smart contract con cui interagirai.

Gli ABI sono in genere compilati da smart contract di Solidity con un framework di sviluppo come Hardhat. Spesso puoi trovare gli ABI per uno smart contract anche su Etherscan

Come compilare l'ABI

Ora che abbiamo esaminato lo smart contract di base e sappiamo cosa sono gli ABI, compiliamo un ABI per il nostro progetto.

Per farlo, vai alla riga di comando ed esegui il seguente comando:

npx hardhat compile

Ora dovresti vedere una nuova cartella denominata artifacts nella directory src . Il file artifacts/contracts/Greeter.json contiene l'ABI come una delle proprietà. Quando dobbiamo usare l'ABI, possiamo importarlo dal nostro file JavaScript:

import Greeter from './artifacts/contracts/Greeter.sol/Greeter.json'

Possiamo quindi fare riferimento all'ABI in questo modo:

console.log("Greeter ABI: ", Greeter.abi)

Nota che Ethers.js abilita anche ABI leggibili dall'uomo , ma non ne parleremo durante questo tutorial.

Come distribuire e utilizzare una rete locale / Blockchain

Quindi, distribuiamo il nostro contratto intelligente su una blockchain locale in modo da poterlo testare.

Per eseguire la distribuzione nella rete locale, devi prima avviare il nodo di test locale. Per fare ciò, apri la CLI ed esegui il seguente comando:

npx hardhat node

Quando eseguiamo questo comando, dovresti vedere un elenco di indirizzi e chiavi private.

Si tratta di 20 account di prova e indirizzi creati per noi che possiamo utilizzare per implementare e testare i nostri contratti intelligenti. Ogni account è anche caricato con 10.000 falsi Ether. Tra poco impareremo come importare l'account di prova in MetaMask in modo da poterlo utilizzare.

Successivamente, dobbiamo distribuire il contratto alla rete di test. Per prima cosa aggiorna il nome di scripts/sample-script.js in scripts/deploy.js .

Ora possiamo eseguire lo script di distribuzione e dare un flag alla CLI in modo da distribuire sulla nostra rete locale:

npx hardhat run scripts/deploy.js --network localhost

Una volta eseguito questo script, lo smart contract dovrebbe essere distribuito sulla rete di test locale e dovremmo essere quindi in grado di iniziare a interagire con esso.

Quando il contratto è stato distribuito, utilizzava il primo account creato quando abbiamo avviato la rete locale.

Se guardi l'output della CLI, dovresti essere in grado di vedere qualcosa del genere:

Greeter deployed to: 0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0

Questo indirizzo è quello che useremo nella nostra applicazione client per parlare con lo smart contract. Mantieni questo indirizzo disponibile poiché dovremo usarlo quando ci connettiamo ad esso dall'applicazione client.

Per inviare transazioni allo smart contract, dovremo connettere il nostro portafoglio MetaMask utilizzando uno degli account creati quando abbiamo eseguito npx hardhat node. Nell'elenco dei contratti che la CLI ha stampato, dovresti vedere sia un numero di conto che una chiave privata :

➜  react-defi-stack git:(main) npx hardhat node
Started HTTP and WebSocket JSON-RPC server at http://127.0.0.1:8545/

Accounts
========
Account #0: 0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266 (10000 ETH)
Private Key: 0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80

...

Possiamo importare questo account in MetaMask per iniziare a utilizzare alcuni dei falsi Eth disponibili lì. Per fare ciò, prima apri MetaMask e aggiorna la rete in modo che sia Localhost 8545:

Successivamente, in MetaMask, fai clic su Import Account dal menu degli account:

Copia, quindi incolla una delle chiavi private stampate nella CLI e fai clic su Import. Una volta importato l'account, dovresti vedere l'Eth nell'account:

Ora che abbiamo distribuito il nostro contratto intelligente e configurato il nostro account, possiamo iniziare a interagire con esso dall'app React.

Come collegare il client React

In questo tutorial non ci preoccuperemo di creare una bella interfaccia utente con CSS e tutto il resto: invece ci concentreremo al 100% sulle funzionalità di base per renderti operativo velocemente. Da lì poi, puoi prenderlo e farlo sembrare bello, se lo desideri.

Detto questo, esaminiamo i due obiettivi che desideriamo dalla nostra applicazione React:

1. Recupera il valore corrente di greeting dal contratto intelligente
2. Consenti a un utente di aggiornare il valore di greeting

Quindi, come lo realizziamo? Ecco le cose che dobbiamo fare perché ciò avvenga:

1. Creare un campo di input e uno stato locale per gestire il valore dell'input (per aggiornare il greeting)
2. Consentire all'applicazione di connettersi all'account MetaMask dell'utente per firmare le transazioni
3. Creare le funzioni per leggere e scrivere sullo smart contract

Per fare ciò, apri src/App.js e aggiornalo con il seguente codice, impostando il valore di greeterAddress all'indirizzo del tuo smart contract:

import './App.css';
import { useState } from 'react';
import { ethers } from 'ethers'
import Greeter from './artifacts/contracts/Greeter.sol/Greeter.json'

// Aggiorna con l'indirizzo del contratto stampato dalla CLI quando è stato distribuito 
const greeterAddress = "indirizzo-del-tuo-contratto"

function App() {
  // memorizza il saluto nella stato locale
  const [greeting, setGreetingValue] = useState()

  // richiede l'accesso all'account MetaMask dell'utente
  async function requestAccount() {
    await window.ethereum.request({ method: 'eth_requestAccounts' });
  }

  // chiama lo smart contract, legge il valore attuale del saluto 
  async function fetchGreeting() {
    if (typeof window.ethereum !== 'undefined') {
      const provider = new ethers.providers.Web3Provider(window.ethereum)
      const contract = new ethers.Contract(greeterAddress, Greeter.abi, provider)
      try {
        const data = await contract.greet()
        console.log('data: ', data)
      } catch (err) {
        console.log("Error: ", err)
      }
    }    
  }

  // chiama lo smart contract, invia un aggiornamento
  async function setGreeting() {
    if (!greeting) return
    if (typeof window.ethereum !== 'undefined') {
      await requestAccount()
      const provider = new ethers.providers.Web3Provider(window.ethereum);
      const signer = provider.getSigner()
      const contract = new ethers.Contract(greeterAddress, Greeter.abi, signer)
      const transaction = await contract.setGreeting(greeting)
      await transaction.wait()
      fetchGreeting()
    }
  }

  return (
    <div className="App">
      <header className="App-header">
        <button onClick={fetchGreeting}>Fetch Greeting</button>
        <button onClick={setGreeting}>Set Greeting</button>
        <input onChange={e => setGreetingValue(e.target.value)} placeholder="Set greeting" />
      </header>
    </div>
  );
}

export default App;

Per testarlo, avvia il server React:

npm start

Quando l'app viene caricata, dovresti essere in grado di recuperare il saluto corrente e stamparlo sulla console. Dovresti anche essere in grado di aggiornare il saluto firmando il contratto con il tuo portafoglio MetaMask e spendendo il falso Ether.

Come distribuire e utilizzare una rete di test dal vivo

Esistono diverse reti di test di Ethereum come Ropsten, Rinkeby o Kovan a cui possiamo anche distribuire per avere una versione pubblicamente accessibile del nostro contratto disponibile senza doverla distribuire sulla mainnet.

In questo tutorial verrà distribuito nella rete di test Ropsten .

Per iniziare, aggiorna prima il tuo portafoglio MetaMask per connetterti alla rete Ropsten.

Quindi, invia a te stesso un Ether di prova da utilizzare durante il resto di questo tutorial visitando questo faucet di prova .

Possiamo accedere a Ropsten (o a qualsiasi altra rete di test) iscrivendoci a un servizio come Infura o Alchemy (sto usando Infura per questo tutorial).

Dopo aver creato l'app in Infura o Alchemy, ti verrà assegnato un endpoint simile a questo:

https://ropsten.infura.io/v3/your-project-id

Assicurati di impostare ALLOWLIST ETHEREUM ADDRESSES nella configurazione dell'app Infura o Alchemy per includere l'indirizzo del portafoglio dell'account da cui eseguirai la distribuzione.

Per eseguire il deployment nella rete di test, è necessario aggiornare la nostra configurazione di Hardhat con alcune informazioni di rete aggiuntive. Una delle cose che dobbiamo impostare è la chiave privata del portafoglio da cui eseguiremo il deployment.

Per ottenere la chiave privata, puoi esportarla da MetaMask.

Suggerirei di non codificare questo valore nella tua app, ma invece di impostarlo come una variabile di ambiente.

Quindi, aggiungi una proprietà networks con la seguente configurazione:

module.exports = {
  defaultNetwork: "hardhat",
  paths: {
    artifacts: './src/artifacts',
  },
  networks: {
    hardhat: {},
    ropsten: {
      url: "https://ropsten.infura.io/v3/your-project-id",
      accounts: [`0x${your-private-key}`]
    }
  },
  solidity: "0.7.3",
};

Per eseguire la distribuzione, avviare il seguente script:

npx hardhat run scripts/deploy.js --network ropsten

Una volta distribuito il contratto, dovresti essere in grado di iniziare a interagire con esso. Ora dovresti essere in grado di visualizzare il contratto live su Etherscan Ropsten Testnet Explorer

Come coniare i gettoni

Uno dei casi d'uso più comuni degli smart contract è la creazione di token. Diamo un'occhiata a come possiamo farlo. Dal momento che sappiamo un po' di più su come funziona tutto questo, andremo un po' più veloci.

Nella directory principale dei contracts, crea un nuovo file denominato Token.sol .

Quindi, aggiorna Token.sol con il seguente contratto intelligente:

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.3;

import "hardhat/console.sol";

contract Token {
  string public name = "Nader Dabit Token";
  string public symbol = "NDT";
  uint public totalSupply = 1000000;
  mapping(address => uint) balances;

  constructor() {
    balances[msg.sender] = totalSupply;
  }

  function transfer(address to, uint amount) external {
    require(balances[msg.sender] >= amount, "Gettoni non sufficienti");
    balances[msg.sender] -= amount;
    balances[to] += amount;
  }

  function balanceOf(address account) external view returns (uint) {
    return balances[account];
  }
}

Tieni presente che questo contratto token è solo a scopo dimostrativo e non è conforme a ERC20 . Tratteremo i token ERC20 in seguito.

Questo contratto creerà un nuovo token chiamato "Nader Dabit Token" e imposterà la fornitura a 1000000.

Quindi, compila questo contratto:

npx hardhat compile

Ora, aggiorna lo script di distribuzione su scripts/deploy.js per includere questo nuovo contratto Token:

const hre = require("hardhat");

async function main() {
  const [deployer] = await hre.ethers.getSigners();

  console.log(
    "Distribuzione di contratti con l'account:",
    deployer.address
  );
  
  const Greeter = await hre.ethers.getContractFactory("Greeter");
  const greeter = await Greeter.deploy("Hello, World!");

  const Token = await hre.ethers.getContractFactory("Token");
  const token = await Token.deploy();
  
  await greeter.deployed();
  await token.deployed();

  console.log("Greeter distribuito a:", greeter.address);
  console.log("Token distribuito a:", token.address);
}

main()
  .then(() => process.exit(0))
  .catch(error => {
    console.error(error);
    process.exit(1);
  });

Ora possiamo distribuire questo nuovo contratto sulla rete locale o Ropsten:

npx hardhat run scripts/deploy.js --network localhost

Una volta distribuito il contratto, puoi iniziare a inviare questi token ad altri indirizzi.

Per fare ciò, aggiorniamo il codice client di cui avremo bisogno per farlo funzionare:

import './App.css';
import { useState } from 'react';
import { ethers } from 'ethers'
import Greeter from './artifacts/contracts/Greeter.sol/Greeter.json'
import Token from './artifacts/contracts/Token.sol/Token.json'

const greeterAddress = "il-tuo-indirizzo-di-contratto"
const tokenAddress = "il-tuo-indirizzo-di-contratto"

function App() {
  const [greeting, setGreetingValue] = useState()
  const [userAccount, setUserAccount] = useState()
  const [amount, setAmount] = useState()

  async function requestAccount() {
    await window.ethereum.request({ method: 'eth_requestAccounts' });
  }

  async function fetchGreeting() {
    if (typeof window.ethereum !== 'undefined') {
      const provider = new ethers.providers.Web3Provider(window.ethereum)
      console.log({ provider })
      const contract = new ethers.Contract(greeterAddress, Greeter.abi, provider)
      try {
        const data = await contract.greet()
        console.log('data: ', data)
      } catch (err) {
        console.log("Error: ", err)
      }
    }    
  }

  async function getBalance() {
    if (typeof window.ethereum !== 'undefined') {
      const [account] = await window.ethereum.request({ method: 'eth_requestAccounts' })
      const provider = new ethers.providers.Web3Provider(window.ethereum);
      const contract = new ethers.Contract(tokenAddress, Token.abi, provider)
      const balance = await contract.balanceOf(account);
      console.log("Balance: ", balance.toString());
    }
  }

  async function setGreeting() {
    if (!greeting) return
    if (typeof window.ethereum !== 'undefined') {
      await requestAccount()
      const provider = new ethers.providers.Web3Provider(window.ethereum);
      console.log({ provider })
      const signer = provider.getSigner()
      const contract = new ethers.Contract(greeterAddress, Greeter.abi, signer)
      const transaction = await contract.setGreeting(greeting)
      await transaction.wait()
      fetchGreeting()
    }
  }

  async function sendCoins() {
    if (typeof window.ethereum !== 'undefined') {
      await requestAccount()
      const provider = new ethers.providers.Web3Provider(window.ethereum);
      const signer = provider.getSigner();
      const contract = new ethers.Contract(tokenAddress, Token.abi, signer);
      const transation = await contract.transfer(userAccount, amount);
      await transation.wait();
      console.log(`${amount} Coins successfully sent to ${userAccount}`);
    }
  }

  return (
    <div className="App">
      <header className="App-header">
        <button onClick={fetchGreeting}>Fetch Greeting</button>
        <button onClick={setGreeting}>Set Greeting</button>
        <input onChange={e => setGreetingValue(e.target.value)} placeholder="Set greeting" />

        <br />
        <button onClick={getBalance}>Get Balance</button>
        <button onClick={sendCoins}>Send Coins</button>
        <input onChange={e => setUserAccount(e.target.value)} placeholder="Account ID" />
        <input onChange={e => setAmount(e.target.value)} placeholder="Amount" />
      </header>
    </div>
  );
}

export default App;

Quindi, esegui l'app:

npm start

Dovremmo essere in grado di fare clic su Get Balance e vedere che abbiamo 1.000.000 di monete nel nostro account stampato sulla console.

Dovresti anche essere in grado di visualizzarli in MetaMask facendo clic su Add Token:

Quindi fai clic su Custom Token e inserisci l'indirizzo del contratto del token e poi Add Token . Ora i token dovrebbero essere disponibili nel tuo portafoglio:

Quindi, proviamo a inviare quelle monete a un altro indirizzo.

Per fare ciò, copia l'indirizzo di un altro account e invialo a quell'indirizzo utilizzando l'interfaccia utente di React aggiornata. Quando controlli l'importo del token, dovrebbe essere uguale all'importo originale meno l'importo che hai inviato all'indirizzo.

Come costruire un token ERC20

Lo standard dei token ERC20 definisce un insieme di regole che si applicano a tutti i token ERC20 che consentono loro di interagire facilmente tra loro. ERC20 rende davvero facile per qualcuno coniare i propri token che avranno interoperabilità con altri sulla blockchain di Ethereum.

Diamo un'occhiata a come possiamo costruire il nostro token utilizzando lo standard ERC20.

Innanzitutto, installa la libreria di smart contract ERC20  OpenZepplin in cui importeremo il token di base:

npm install @openzeppelin/contracts

Successivamente, creeremo il nostro token estendendo (o ereditando) il contratto ERC20:

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.3;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract NDToken is ERC20 {
    constructor(string memory name, string memory symbol) ERC20(name, symbol) {
        _mint(msg.sender, 100000 * (10 ** 18));
    }
}

Il costruttore consente di impostare il nome e il simbolo del token e la funzione _mint consente di coniare i token e di impostare l'importo.

Per impostazione predefinita, ERC20 imposta il numero di decimali a 18, quindi nella nostra funzione _mint moltiplichiamo 100.000 per 10 alla potenza 18 per coniare un totale di 100.000 gettoni, ciascuno con 18 cifre decimali (in modo simile a come 1 Eth è composto da 10 a 18 wei .

Per distribuire, dobbiamo passare i valori del costruttore (name e symbol), quindi potremmo fare qualcosa del genere nel nostro script di distribuzione:

const NDToken = await hre.ethers.getContractFactory("NDToken");
const ndToken = await NDToken.deploy("Nader Dabit Token", "NDT");

Estendendo il token ERC20 originale, il tuo token erediterà tutte le seguenti funzioni e funzionalità:

function name() public view returns (string)
function symbol() public view returns (string)
function decimals() public view returns (uint8)
function totalSupply() public view returns (uint256)
function balanceOf(address _owner) public view returns (uint256 balance)
function transfer(address _to, uint256 _value) public returns (bool success)
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success)
function approve(address _spender, uint256 _value) public returns (bool success)
function allowance(address _owner, address _spender) public view returns (uint256 remaining)

Una volta implementato, puoi utilizzare una qualsiasi di queste funzioni per interagire con il nuovo contratto intelligente. Per un altro esempio di token ERC20, dai un'occhiata a Solidity by example qui: https://solidity-by-example.org/app/erc20/ .

Conclusione

Ok, abbiamo trattato molto in questo articolo. Ma per me questo è una specie di pane quotidiano / essenziale per iniziare con questo stack.

È un po' quello che volevo avere, non solo come qualcuno che sta imparando tutte queste cose, ma anche in futuro, se mai avessi bisogno di fare riferimento a qualcosa di cui potrei aver bisogno. Spero che tu abbia imparato molto.

Se desideri supportare più portafogli oltre a MetaMask, dai un'occhiata a Web3Modal che semplifica l'implementazione del supporto per più provider nella tua app con una configurazione abbastanza semplice e personalizzabile.

Nei miei futuri tutorial e guide, mi immergerò nello sviluppo di contratti intelligenti più complessi e anche su come distribuirli come sottografi per esporre un'API GraphQL su di essi e implementare cose come l'impaginazione e la ricerca full-text.

Tratterò anche di come utilizzare tecnologie come IPFS e database Web3 per archiviare i dati in modo decentralizzato.

Se hai domande o suggerimenti per futuri tutorial, fammi sapere.

Ultimamente, ho parlato del mio passaggio allo spazio Web3 , Ethereum e crypto, cioè da quando sono passato da una conoscenza tradizionale del Web, mobile e cloud.

Da quando ho fatto ciò, un numero impressionante di persone mi ha contattato e anche loro stanno pensando di fare lo stesso.

È davvero fantastico vedere così tante altre persone interessate a questi campi. E se devo essere onesto, è confortante sapere che anche così tanti altri sono in osservazione e sono anche così profondamente interessati al questo contesto.

Quanto a me, ero nervoso all'idea di cambiare carriera. Il passaggio a un'area di specializzazione completamente nuova, con una tecnologia su cui mi stavo ancora potenziando e una comunità in cui non ero ancora coinvolto, è stato un grande salto. Soprattutto rispetto a un lavoro molto comodo in un'azienda FAANG, con un'ottimo stipendio (e una squadra che ho davvero amato).

Dopo oltre un mese, non ho rimpianti per il cambiamento. Sono anche più felice e sono eccitato e pieno di energia per le cose su cui ho l'opportunità di lavorare ogni giorno.

Ho deciso di scrivere questo post per fornire indicazioni a chiunque cerchi di entrare in blockchain, criptovalute, Ethereum e Web3 da un background di sviluppo tradizionale. Posso indirizzare le persone a questo mio post sul blog la prossima volta che mi verrà chiesto su come entrare in questo ambito.

Dividerò questo articolo in alcune parti principali:

1. Tecnologie e risorse per imparare
2. Compromessi e considerazioni
3. Persone da seguire
4. Aziende che assumono e fanno cose interessanti
5. Suggerimenti generali e ottenimento di un lavoro

Iniziamo.

Tecnologie e risorse per conoscere Ethereum e Blockchain

Quello che mi interessa di più è di solito cercare di prevedere dove la tecnologia andrà nel prossimo futuro e dove vedo l'attuale slancio. Quindi è su questo che mi concentrerò qui (ed è quello che sto facendo personalmente).

Per me, le parti più interessanti di questo spazio sono la decentralizzazione, la DeFi , la governance / DAO e l'infrastruttura web decentralizzata .

Per questo motivo, mi sto concentrando sia sullo sviluppo di Ethereum che su Solidity. Con il linguaggio di programmazione Solidity, puoi programmare contratti intelligenti per Ethereum e per molti altri blockchain compatibili con EVM .

Al momento della stesura di questo articolo, Ethereum ha anche la potente e importante combinazione di slancio, condivisione mentale degli sviluppatori e dapp di produzione esistenti .

Anche Ethereum sta attualmente passando a un nuovo meccanismo di consenso, proof of stake . Questo risolve le preoccupazioni ambientali che avevo su come funziona la criptovaluta a livello centrale.

Dopo aver appreso le basi di come funziona il tutto, ti incoraggio a controllare altri blockchain e progetti al di fuori di Ethereum ed EVM.

Questo ti darà una migliore comprensione del settore nel suo insieme. Ti aiuterà anche a vedere se ci sono altri progetti che ti attraggono o che ritieni siano approcci migliori per raggiungere l'obiettivo che è Web3.

Considera di esaminare Solana , Polkadot , Near , Avalanche o Cosmos .

Per iniziare ad imparare lo sviluppo della blockchain con Ethereum e Solidity, ti suggerisco di fare quanto segue:

1. Leggi la documentazione di Ethereum

Esplora la documentazione di Ethereum. Assicurati di controllare la sezione Introduzione a Ethereum e qualsiasi altra cosa che attiri la tua attenzione.

Assicurati anche di dare un'occhiata alla vetrina di dapp per avere una buona comprensione delle app di successo create e utilizzate nell'attuale ecosistema.

2. Leggi la documentazione di Solidity

La documentazione di Solidity è un ottimo punto di partenza, in particolare la Solidity tramite esempio . Questo ti offre alcuni esempi di contratti intelligenti popolari come il voto, un'asta, l'acquisto a distanza e i micropagamenti.

Puoi copiare e incollare questi contratti nell'IDE Remix per iniziare a eseguirli e modificarli per vedere come funzionano.

Ho anche fatto un video sulla procedura dettagliata del contratto di voto qui .

3. Mettiti comodo con Remix IDE

È davvero facile giocare e iniziare a creare contratti intelligenti senza dover configurare alcun tipo di ambiente di sviluppo utilizzando Remix IDE . Fa parte del Remix Project , finanziato dalla Ethereum Foundation .

Questo Remix IDE ti consente di creare, modificare ed eseguire contratti intelligenti direttamente dal tuo browser. Offre un ambiente perfetto per imparare come funziona Solidity. È anche ottimo per creare vari tipi di contratti intelligenti e giocarci mentre impari sia Solidity che come interagire con Ethereum

4. Prova a creare un dapp full stack

Oltre a Solidity, le altre parti dello stack di sviluppo includono un ambiente Ethereum locale come Hardhat o Truffle , un portafoglio come Metamask , nonché una libreria lato client che ti consente di interagire con la blockchain, come Ethers.js o Web3.js .

Per capire come tutto questo si adatta insieme, è utile creare da zero un dapp full stack su questo complesso di elementi. Puoi impostare il progetto front-end e l'ambiente di sviluppo locale e distribuire, eseguire e interagire con uno smart contract sulla blockchain.

Ecco due corsi introduttivi per iniziare con questo:

1. Tutorial di programmazione Ethereum - DeFi, Solidity, Truffle, Web3.js
2. La guida completa allo sviluppo di Full Stack Ethereum ( ed eccola anche sotto forma di articolo )

5. Considera la lettura di questi libri

Lo spazio stesso si muove molto rapidamente, quindi i libri tecnici spesso diventano obsoleti altrettanto rapidamente. I fondamenti di ciò che è Web3, tuttavia, non sono cambiati molto.

Ci sono alcuni libri davvero fantastici che mi hanno aiutato non solo a cogliere lo stato attuale di ogni cosa, ma che mi hanno anche aiutato ad aprire gli occhi sulle possibilità e opportunità future che si trovano al suo interno.

Token Economy - Come il Web3 reinventa Internet

Se hai intenzione di leggere solo uno di questi libri, questo è quello che direi che è il più importante. È un'immersione magistrale in tutte le carenze del web come lo conosciamo, cosa vuole essere il Web3, come influenzerà le varie parti della nostra vita attuale e cosa deve accadere affinché questa visione si realizzi .

Puoi visualizzare il libro qui .

The Infinite Machine - Come un esercito di cripto-hacker sta costruendo la prossima Internet con Ethereum

Questa è la straordinaria storia di come è nato Ethereum, guidandoti attraverso la storia di tutto questo. È un resoconto molto approfondito e divertente della storia delle origini di Ethereum, consiglio vivamente di provarlo.

Puoi visualizzare il libro qui .

New Village - Ritorno al potere delle persone

Questa è una storia davvero interessante su come le tecnologie blockchain e il decentramento influenzeranno il futuro del mondo.

Puoi visualizzare il libro qui

How to DeFi

Come probabilmente puoi intuire dal titolo, questo libro si concentra su come puoi iniziare a utilizzare la DeFi oggi. Ti dà una buona comprensione di come puoi usarla oggi e di alcune sue applicazioni che vedremo in futuro.

Puoi visualizzare il libro qui

The Spatial Web

The Spatial Web è un libro che esplora il futuro del web e tutte le implicazioni, non solo del Web3 e del decentramento, ma come tutto si unirà per consentire cose che potremmo non aver ancora considerato.

Fa un buon lavoro soppesando gli aspetti positivi e negativi, nonché i modi in cui potremmo essere in grado di affrontare eventuali esiti negativi di ciò che verrà.

Puoi visualizzare il libro qui

Ed ecco un paio di libri su solidity:

• Sviluppo pratico di contratti intelligenti con Solidity ed Ethereum
• Padroneggiare Ethereum

6. Ascolta questi podcast

Ecco alcuni buoni podcast:

• Fondatori di Web 3 – Le persone che stanno creando e costruendo la prossima fase di Internet.
• Bankless : la guida definitiva alla criptofinanza
• Into the Ether – Podcast su Ethereum
• Cripto 101
• Epicenter : scopri le tecnologie Crypto, Blockchain, Ethereum, Bitcoin e distribuite

7. Guarda questi canali YouTube

• Fondazione Ethereum
• Eat the Blocks – Brevi video sullo sviluppo della blockchain
• Finematics – Condivisione di video DeFi interessanti
• Dapp University – Video nello spazio di Ethereum
• BlockGeeks – Formazione Blockchain generale
• Il quotidiano Gwei
• Austin Griffith

Ho anche iniziato a fare video e tutorial su Ethereum e Solidity, quindi considera di dare un'occhiata al mio canale YouTube.

Compromessi e considerazioni sul cambio di carriera

Ci sono sempre cose da considerare quando si effettua una transizione di carriera, ma soprattutto quando si considera questo contesto.

Ci sono molti aspetti positivi, ma ci sono anche incognite come anche aspetti negativi. Parliamo di alcuni di loro.

È una tecnologia nascente

Mentre ci sono molte dapp esistenti e aziende già fiorenti, questo spazio sta ancora nascendo in molti modi.

Ci sono molti problemi che dobbiamo ancora risolvere e non ci sono risposte chiare per molte domande che avrai. I problemi da risolvere sono spesso complessi, a volte combinano uno o più aspetti dei sistemi distribuiti, teoria dei giochi, crittografia, economia, scienze sociali e politiche, identità, psicologia e altro ancora.

Per questo motivo, ci sono ancora cose che non possiamo finora costruire con le soluzioni esistenti che sono attualmente disponibili.

Personalmente penso che questa sia una delle cose più eccitanti di tutto ciò, ma non è per tutti.

È uno spazio volatile

Molti dei progetti sono costruiti attorno a vari tipi di token. Il valore di molti di questi gettoni aumenta e diminuisce drasticamente e spesso si vede che le persone guadagnano e perdono interesse all'argomento in base a queste oscillazioni.

Se non hai fondamentalmente accettato le idee alla base del decentramento stesso, potresti trovare questi alti e bassi mentalmente faticosi.

È pieno di speculazione

Poiché molta gente acquista determinati token unicamente a scopo speculativo, ciò attira alcune persone solo per i soldi.

Vedi cose come truffatori che cercano di avere la meglio sulle persone e rubare i loro soldi, discorsi interminabili sulle oscillazioni dei prezzi da parte di persone che speculano e veri e propri progetti truffa che spesso screditano l'industria nel suo insieme.

Questa è una parte fastidiosa e non penso che se terminerà presto.

Questa discussione

Vorrei anche che tu dia un'occhiata a questa discussione su Twitter. Anche se non ho sperimentato tutte queste cose, sta sicuramente chiarendo alcune delle cose che ho visto.

Suggerimenti generali e come ottenere un lavoro Blockchain o relativo alle criptovalute

Ci sono molte aree all'interno dello spazio su cui puoi concentrarti e magari poi fornire un impatto positivo su una squadra. Esaminerei le diverse aree come governance, DeFi, NFT e protocolli web decentralizzati per vedere cosa ti interessa di più e poi concentrarti su quello.

Ci sono molte opportunità e molti modi per distinguersi e farsi notare. Se trovi un progetto interessante e vorresti essere coinvolto, entra subito nella loro comunità ed ecosistema e inizia ad imparare. Quindi vedi dove potresti essere in grado di dare una mano. Unisciti a Discord o guarda i loro problemi su GitHub per trovare modi in cui puoi contribuire.

Questo ti darà l'opportunità di incontrare persone coinvolte nel progetto e aprirà discussioni per ottenere potenzialmente un ruolo con loro. In effetti, è molto comune che le persone all'interno dei team prendano nota dei partecipanti più attivi della comunità, quindi spesso ti contattano e cercheranno di reclutarti senza nemmeno candidarti.

La paga è generalmente buona. A seconda da dove vieni, potrebbe essere maggiore o minore, ma probabilmente non sarà ai livelli elevati di quello che vedi nelle aziende FAANG.

Probabilmente c'è più potenziale di rialzo. La maggior parte delle aziende offre una combinazione di retribuzione base + equità sotto forma di token digitale, quindi se rimani e puoi contribuire a rendere il progetto di successo e il valore del token aumenta, spesso puoi guadagnare di più di quanto faresti in molti altre aree.

Persone da seguire su Twitter

Ecco alcune persone che potresti considerare di seguire su Twitter:

Vitalik
Ashleigh Schapp
Arthur Hayes
Stani Kulechov
Gloria Kimbwala
Niran Babalola
Ric Burton
Dennison Bertram
Mana Silvora
Austin Griffith
Santiago Palladino
Zaki Manian
Anthony Sassano

Ho anche trovato questo elenco completo creato da qualcuno su Twitter.

Alcune persone nel mio team di Edge & Node :
Yaniv Tal
Tegan Kline
Eva Beylin
Adam Fuller
Brandon Ramirez

Squadre che fanno cose interessanti (e assunzioni)

Compound
Uniswap
Chainlink
Skynet Labs
Aave
Matic
Livepeer
Consensys
ENS
OpenZeppelin
Foundation
Zora
Synthetix
Digital Currency Group

Puoi anche trovare un elenco abbastanza decente di opportunità di lavoro in criptovaluta qui .

Inoltre, il mio team di Edge & Node sta assumendo !

Conclusione

Ho già detto che questo spazio è volatile? Preparati per alcuni alti e bassi, ma anche per alcuni dei momenti più divertenti che potresti avere nella tua carriera.

Lavorerai al fianco di alcune delle persone più intelligenti nell'ambito della tecnologia cercando di risolvere alcuni dei problemi più complessi che penso che alla fine avranno un enorme impatto positivo sull'umanità.

Se stai leggendo questo articolo, allora sei un utente del web moderno. Il web che stiamo vivendo oggi è molto diverso da quello che era solo 10 anni fa. Come si è evoluto il web e, soprattutto, dove sta andando? Inoltre, perché una qualsiasi di queste cose è importante?

Se la storia ci ha insegnato qualcosa, allora questi cambiamenti sono molto importanti.

In questo articolo, illustrerò come si è evoluto il Web, dove sta andando e perché questo è importante.

Pensa a come Internet influisce sulla tua vita ogni giorno. Considera come la società è cambiata a causa di Internet. Piattaforme di social media. App per telefoni. E ora Internet sta attraversando un altro cambio di paradigma mentre parliamo.

L'evoluzione del web

Il web si è evoluto molto nel corso degli anni e le sue applicazioni oggi sono quasi irriconoscibili rispetto ai suoi primi giorni . L'evoluzione del web è spesso suddivisa in tre fasi separate: Web 1.0, Web 2.0 e Web 3.0.

Che cos'è il Web 1.0?

Il Web 1.0 è stata la prima iterazione del Web. La maggior parte degli utenti erano consumatori di contenuti e i creatori erano in genere sviluppatori che costruivano siti Web che contenevano informazioni fornite principalmente in formato testo o immagine. Il Web 1.0 è durato approssimativamente dal 1991 al 2004.

Il Web 1.0 consisteva in siti che servivano contenuto statico anziché HTML dinamico. I dati e il contenuto venivano serviti da un file system statico anziché da un database e i siti non avevano affatto molta interattività.

Puoi pensare al Web 1.0 come al Web di sola lettura.

Che cos'è il Web 2.0?

La maggior parte di noi ha sperimentato principalmente il web nella sua forma attuale, comunemente indicata come web2 . Puoi pensare a web2 come al web interattivo e sociale.

Nel mondo web2, non devi essere uno sviluppatore per partecipare al processo di creazione. Molte app sono costruite in modo da consentire facilmente a chiunque di essere un creatore.

Se vuoi esprimere un pensiero e condividerlo con il mondo, puoi farlo. Se vuoi caricare un video e consentire a milioni di persone di vederlo, interagire con esso e commentarlo, puoi fare anche questo.

Web2 è semplice, davvero, e grazie alla sua semplicità sempre più persone in tutto il mondo stanno diventando creatori.

Il web nella sua forma attuale è in molti modi davvero fantastico, ma ci sono alcune aree in cui lo si può migliorare.

Monetizzazione e Sicurezza nel Web 2.0

Nel mondo web2, molte delle app popolari seguono uno schema comune nei loro cicli di vita. Pensa ad alcune delle app che utilizzi quotidianamente e a come i seguenti esempi potrebbero applicarsi a loro.

Monetizzazione delle app

Immagina i primi giorni di applicazioni popolari come Instagram, Twitter, LinkedIn o YouTube e quanto siano oggi diverse. Il processo di solito va in questo modo:

1. L'azienda lancia un'app
2. Raccoglie il maggior numero possibile di utenti
3. Quindi monetizza la sua base di utenti

Quando uno sviluppatore o un'azienda lancia un'app popolare, l'esperienza dell'utente è spesso molto fluida quindi l'app continua a crescere in popolarità. Questo è il motivo per cui inizialmente sono in grado di guadagnare rapidamente consensi.

All'inizio, molte società di software non si preoccupano della monetizzazione. Si concentrano rigorosamente sulla crescita e sull'acquisizione di nuovi utenti, ma alla fine devono iniziare a realizzare un profitto.

Devono anche considerare il ruolo degli investitori esterni. Spesso i vincoli legati all'assunzione di cose come il capitale di rischio influiscono negativamente sul ciclo di vita, e infine sull'esperienza dell'utente, di molte applicazioni che oggi utilizziamo.

Se un'azienda che crea un'applicazione prende capitale di rischio, i suoi investitori spesso si aspettano un ritorno sull'investimento dell'ordine di decine o centinaia di volte quello che hanno pagato.

Ciò significa che, invece di perseguire un modello di crescita sostenibile che possa sostenerla in modo alquanto organico, l'azienda è spesso spinta verso due strade: pubblicità o vendita di dati personali.

Per molte aziende web2 come Google, Facebook, Twitter e altre, più dati portano a annunci più personalizzati. Ciò porta a più clic e, in definitiva, a maggiori entrate pubblicitarie. Lo sfruttamento e la centralizzazione dei dati degli utenti è fondamentale per il modo in cui il Web come lo conosciamo e lo utilizziamo oggi è progettato per funzionare.

Sicurezza e privacy

Le applicazioni Web2 subiscono ripetutamente violazioni dei dati. Esistono persino siti Web dedicati a tenere il passo con queste violazioni e a dirti quando i tuoi dati sono stati compromessi.

Nel web2, non hai alcun controllo sui tuoi dati o su come vengono archiviati. In effetti, le aziende spesso tracciano e salvano i dati degli utenti senza il consenso degli utenti stessi. Tutti questi dati sono quindi posseduti e controllati dalle società incaricate di queste piattaforme.

Anche gli utenti che vivono in paesi in cui devono preoccuparsi delle conseguenze negative della libertà di parola sono a rischio.

I governi spesso chiudono i server o sequestrano conti bancari se ritengono che una persona stia esprimendo un'opinione contraria alla loro propaganda. Con i server centralizzati, è facile per i governi intervenire, controllare o chiudere le applicazioni come meglio credono.

Poiché anche le banche sono digitali e sotto il controllo centralizzato, i governi spesso intervengono anche lì. Possono bloccare l'accesso ai conti bancari o limitare l'accesso ai fondi durante i periodi di volatilità, inflazione estrema o anche disordini politici.

Web3 mira a risolvere molte di queste carenze ripensando fondamentalmente da zero al modo in cui progettiamo e interagiamo con le applicazioni.

Che cos'è il Web 3.0?

Ci sono alcune differenze fondamentali tra web2 e web3, ma il decentramento è al centro.

Web3 migliora Internet come lo conosciamo oggi con alcune altre caratteristiche aggiuntive. web3 è:

• Verificabile
• Senza fiducia
• Autogovernante
• Senza autorizzazione
• Distribuito e robusto
• Stateful
• Pagamenti integrati nativi

Nel web3, gli sviluppatori di solito creano e distribuiscono applicazioni che non vengono eseguite su un unico server o che archiviano i propri dati in un unico database (di solito ospitato e gestito da un unico fornitore di servizi cloud).

Invece, le applicazioni web3 funzionano su blockchain, reti decentralizzate di molti nodi peer to peer (server) o una combinazione dei due che forma un protocollo crittoeconomico . Queste app sono spesso denominate dapp (app decentralizzate) e vedrai questo termine usato spesso nello spazio web3.

Per ottenere una rete decentralizzata stabile e sicura, i partecipanti alla rete (sviluppatori) sono incentivati ​​e competono per fornire servizi della massima qualità a chiunque utilizzi il servizio.

Quando senti parlare di web3, noterai che la criptovaluta è spesso parte del contesto. Questo perché la criptovaluta gioca un ruolo importante in molti di questi protocolli. Fornisce un incentivo finanziario (token) per chiunque voglia partecipare alla creazione, governo, contribuzione o miglioramento di uno dei progetti stessi.

Questi protocolli possono spesso offrire una varietà di servizi diversi come elaborazione, archiviazione, larghezza di banda, identità, hosting e altri servizi Web comunemente forniti in passato dai provider di servizi cloud.

Le persone possono guadagnarsi da vivere partecipando al protocollo in vari modi, sia a livello tecnico che non.

I consumatori del servizio di solito pagano per utilizzare il protocollo, in modo simile a come pagherebbero oggi un provider di servizi cloud come AWS. Tranne che nel web3, il denaro va direttamente ai partecipanti della rete.

In questo, come in molte forme di decentramento, vedrai che gli intermediari inutili e spesso inefficienti vengono eliminati.

Molti protocolli di infrastruttura web come Filecoin , Livepeer , Arweave e The Graph (che è ciò con cui lavoro in Edge & Node) hanno emesso token di utilità che regolano il funzionamento del protocollo. Questi token premiano anche i partecipanti a molti livelli della rete. Anche i protocolli blockchain nativi come Ethereum funzionano in questo modo.

Pagamenti nativi

I token introducono anche un livello di pagamento nativo che è completamente senza confini e con complessità ridotte. Aziende come Stripe e Paypal hanno creato miliardi di dollari di valore abilitando i pagamenti elettronici.

Questi sistemi sono eccessivamente complessi e ancora non consentono una vera interoperabilità internazionale tra i partecipanti. Richiedono inoltre che tu consegni le tue informazioni sensibili e i tuoi dati personali per poterli utilizzare.

I portafogli crittografici come MetaMask e Torus ti consentono di integrare facilmente nelle applicazioni web3 pagamenti e transazioni internazionali, anonimi e sicuri.

Reti come Solana offrono una latenza di diverse centinaia di millisecondi e costi di transazione di una piccola frazione di un centesimo. A differenza dell'attuale sistema finanziario, gli utenti non devono passare attraverso i tradizionali numerosi passaggi pieni di complessità per interagire e partecipare alla rete. Tutto ciò che devono fare è scaricare o installare un portafoglio e possono iniziare a inviare e ricevere pagamenti senza alcun controllo.

Un nuovo modo di costruire imprese

I token portano anche l'idea della tokenizzazione e la realizzazione di un'economia dei token .

Prendi, ad esempio, la costruzione di una società di software al giorno d'oggi. Qualcuno ha un'idea, ma per iniziare a costruire ha bisogno di soldi per mantenersi.

Per ottenere i soldi, prendono investimenti e danno via una percentuale della società. Questo investimento introduce immediatamente incentivi disallineati che, a lungo termine, non si allineeranno bene con la creazione della migliore esperienza utente.

Inoltre, se l'azienda dovesse mai avere successo, le persone coinvolte impiegheranno molto tempo a realizzare il valore, portando spesso ad anni di lavoro senza alcun reale ritorno sull'investimento.

Immagina, invece, che venga annunciato un nuovo ed entusiasmante progetto che risolve un problema reale. Chiunque può partecipare dal primo giorno alla sua costruzione o investire su di esso. L'azienda annuncia il rilascio di un numero x di token e dà il 10% ai primi costruttori, mette il 10% in vendita al pubblico e mette da parte il resto per il futuro pagamento dei contributori e il finanziamento del progetto.

Le parti interessate possono utilizzare i loro token per votare sulle modifiche al futuro del progetto e le persone che hanno contribuito a costruire il progetto possono vendere alcune delle loro partecipazioni per fare soldi dopo che i token sono stati rilasciati.

Le persone che credono nel progetto possono acquistare e mantenere la proprietà, e le persone che pensano che il progetto stia andando nella direzione sbagliata possono segnalarlo vendendo la loro partecipazione.

Poiché i dati blockchain sono tutti completamente pubblici e aperti, gli acquirenti hanno la completa trasparenza su ciò che sta accadendo. Ciò è in contrasto con l'acquisto di azioni in aziende private o centralizzate in cui molte cose sono spesso nascoste.

Questo sta già accadendo nello spazio web3.

Un esempio è l'app Radicle (un'alternativa decentralizzata a GitHub) che consente agli stakeholder di partecipare alla governance del loro progetto. Gitcoin è un altro che consente agli sviluppatori di essere pagati in criptovaluta per entrare e lavorare su problemi Open Source. Yearn consente alle parti interessate di partecipare al processo decisionale e al voto sulle proposte. Uniswap , SuperRare , The Graph , Audius e innumerevoli altri protocolli e progetti hanno emesso token come un modo per abilitare la proprietà, la partecipazione e la governance.

Le DAO (organizzazioni autonome decentralizzate), che offrono un modo alternativo per costruire ciò che tradizionalmente consideravamo un'azienda, stanno guadagnando un enorme slancio e investimenti sia da parte degli sviluppatori tradizionali che delle società di capitale di rischio.

Questi tipi di organizzazioni sono tokenizzati e capovolgono l'idea di struttura organizzativa, offrendo una proprietà reale, liquida ed equa a porzioni più ampie di stakeholder e allineando gli incentivi in ​​modi nuovi e interessanti.

Ad esempio, Friends with Benefits è un DAO di costruttori e artisti web3, ha circa un anno, ha una capitalizzazione di mercato di circa $ 125 milioni al momento della stesura di questo articolo e ha recentemente ricevuto un investimento di $ 10 milioni da a16z .

I DAO potrebbero richiedere un intero post per sé, ma per ora dirò solo che penso che siano il futuro per la costruzione di prodotti e (come lo si pensava in passato) di aziende. Ecco un buon post che delinea l'attuale panorama DAO.

Come funziona l'identità in Web3

In web3, anche l'Identity funziona in modo molto diverso da quello a cui siamo abituati oggi. La maggior parte delle volte nelle app web3, le identità saranno legate all'indirizzo del portafoglio dell'utente che interagisce con l'applicazione.

A differenza dei metodi di autenticazione web2 come OAuth o email + password (che quasi sempre richiedono agli utenti di consegnare informazioni sensibili e personali), gli indirizzi del portafoglio sono completamente anonimi a meno che l'utente non decida di legarvi pubblicamente la propria identità.

Se l'utente sceglie di utilizzare lo stesso portafoglio su più dapp, la sua identità è anche trasferibile senza problemi tra le app, il che consente loro di costruire la propria reputazione nel tempo.

Protocolli e strumenti come Ceramic e IDX consentono già agli sviluppatori di creare identità self-sovereign nelle loro applicazioni per sostituire i tradizionali livelli di autenticazione e identità. La fondazione Ethereum ha anche una RFP funzionante per la definizione di una specifica per "Accedi con Ethereum" che aiuterebbe a fornire un modo più snello e documentato per far ciò in futuro. Questo è anche un buona discussione che delinea alcuni dei modi in cui ciò migliorerebbe i flussi di autenticazione tradizionali.

Come costruire su Web3

Sono uno sviluppatore che è recentemente passato allo spazio web3 da un background di sviluppo tradizionale. Quindi volevo iniziare a costruire per avere un'idea di come fosse l'esperienza di sviluppo. E volevo capire i tipi di app che si possono creare oggi.

Mi sono tuffato subito e ho deciso di documentare alcune delle cose che stavo facendo in un paio di post sul blog.

Come entrare in Ethereum, Crypto e Web3 come sviluppatore – Questa è un'introduzione in generale al tema, proveniente da uno sviluppatore, per gli sviluppatori che cercano di entrare nel settore.

La guida completa allo sviluppo di Full Stack Ethereum – Questo è un tutorial che ti insegna come costruire la tua prima dapp.

La guida completa allo sviluppo di Solana full stack con React, Anchor, Rust e Phantom - Questa guida si tuffa in Solana per mostrarti come costruire un dapp full stack.

Se sei interessato a saperne di più su web3 in generale, puoi dare un'occhiata a questi post:

La nuova economia dei creatori: DAO, proprietà della comunità e criptoeconomia

La catena del valore del metaverso aperto

L'ascesa delle microeconomie