A jornada da maioria das pessoas ao aprender a programar começa com uma pesquisa de madrugada no Google.

Geralmente é algo como "Aprender _____"

Como será, no entanto, que eles decidem qual linguagem pesquisar?

"Eles sempre fazem piadas com o Java no Vale do Silício. Acho que é o que eu vou aprender."

Ou:

"Haskell. Parece estar na moda agora. Haskell."

Ou:

"Aquele esquilinho do Go é tão fofinho."

‌Existe, também, o resto de nós que, provavelmente, procuraremos por algo do tipo:

"Qual linguagem de programação eu deveria aprender primeiro?"

Poucas perguntas são feitas tão frequentemente ao ponto de ganhar um infográfico completo sobre elas. Essa é uma delas:

Decidir sua primeira linguagem de programação pode ser um processo divertido – tipo um daqueles quizzes de personalidade – "Qual personagem do Quentin Tarantino você é?".

Antes, no entanto, de você começar a aprender Ruby porque você adorava brincar com Play-Doh quando era criança, deixe-me lembrar: as apostas são bem altas aqui.

Vai demorar muitas horas de prática para você se tornar remotamente alguém competente com a sua primeira linguagem de programação.

Então você deve considerar os seguintes fatores:

• o mercado de trabalho para a linguagem
• as perspectivas de longo prazo da linguagem
• qual é a facilidade para aprender a linguagem
• quais projetos você poderá construir enquanto estiver aprendendo (e compartilhar com os amigos para mantê-lo motivado)

A cada ano, uma nova linguagem aparece. Com ela, novos artigos acadêmicos – e novas tirinhas também.

Sério, olha essa pérola do mês passado:

Quando se trata de escolher a primeira linguagem de programação, opção é o que não falta. Para restringir um pouco, aqui estão as pesquisas mais comuns do Google relacionadas à aprendizagem de programação nos últimos 12 anos:

O Java teve seus altos e baixos.

O Python cresceu gradualmente e se tornou a escolha mais popular.

Escondido abaixo deles, porém, está a pequena locomotiva, lentamente ganhando popularidade nos últimos anos. Essa locomotiva é o JavaScript.

Antes de falar sobre essas linguagens de programação, deixe-me esclarecer:

• Não estou argumentando que uma linguagem qualquer é objetivamente melhor do que qualquer outra
• Concordo com o fato de que os desenvolvedores devem eventualmente aprender mais de uma linguagem
• Estou argumentando que, primeiro, eles devem aprender bem uma linguagem. Como você provavelmente já pode adivinhar se deu uma olhada geral no texto – essa linguagem deve ser o JavaScript.

Vamos começar explorando como a programação vem sendo ensinada atualmente na escola.

Introdução à Ciência da Computação

As universidades têm, tradicionalmente, ensinado programação dentro do guarda-chuva da ciência da computação, que é vista por si só como uma extensão da matemática, ou vinculada à formação de engenharia elétrica.

Provavelmente, você já deve ter ouvido o seguinte:

"A educação em ciência da computação não pode fazer de ninguém um programador especialista, assim como estudar pincéis e pigmentos não pode fazer de alguém um especialista em pintura." — Eric S. Raymond

Nesses últimos anos, várias faculdades continuam tratando programação como ciência da computação e ciência da computação como matemática.

Como resultado, muitos dos cursos introdutórios de programação focam em uma linguagem de baixo nível de abstração, como o C, ou linguagens com foco em matemática, como o MATLAB.

Os chefes de departamento geralmente se mantêm nesse ritmo, apontando para tabelas de classificação anuais de linguagens de programação, como o Índice TIOBE (em inglês), ou este índice do IEEE (em inglês):

‌A maior parte desses rankings parece virtualmente idêntica ao que era há 10 anos.

Mudanças acontecem, contudo, mesmo nas universidades.

Em 2014, o Python ultrapassou o Java (em inglês) como a linguagem mais popular nos principais programas de Ciência da Computação dos EUA.

Mais uma mudança, porém, está fadada a acontecer, eventualmente. Se você olhar para as linguagens atualmente usadas no mercado de trabalho, você tem números totalmente diferentes:

Mais da metade de todos os desenvolvedores usa JavaScript. É vital para o desenvolvimento no front-end da web e está ficando cada vez mais relevante para o desenvolvimento no back-end. Elaestá rapidamente se expandindo para áreas como o desenvolvimento de jogos e a Internet das Coisas.

As postagens de trabalhos mencionam o JavaScript mais que qualquer outra linguagem, excetuando o Java:

Não foi por acidente que construímos o currículo da nossa comunidade open source com base no JavaScript. Nos últimos dois anos, mais de 5 mil pessoas usaram o FreeCodeCamp para conseguir seu primeiro emprego como desenvolvedor.

Eu não estou defendendo o JavaScript porque eu o ensino. Eu ensino JavaScript porque é o caminho mais garantido para o primeiro emprego de desenvolvedor.

No entanto, será que o JavaScript é o ideal pra você? Vale a pena fazer do JavaScript sua primeira linguagem de programação? Vamos explorar aqueles fatores que eu mencionei anteriormente.

Fator nº 1: Mercado de trabalho

Se você está aprendendo programação puramente por curiosidade intelectual, sinta-se livre para pular esse fator. Se você, no entanto — como a maioria das pessoas que está aprendendo programação – quer usar essa habilidade para conseguir um emprego, essa é uma consideração importante.

Como mencionei anteriormente, o Java é mais mencionado nos anúncios de emprego do que qualquer outra linguagem de programação. O JavaScript é a segunda – por pouco.

Aqui está algo importante sobre o JavaScript: mesmo existindo há 20 anos, apenas recentemente ele se tornou uma ferramenta séria, com a qual empresas como Netflix, Walmart e PayPal já criaram aplicações inteiras.

Como resultado, várias empresas estão contratando desenvolvedores JavaScript, mas não há muitos no mercado de trabalho.

Existem 2,7 desenvolvedores Java competindo para cada vaga com Java.‌‌ A competição por vagas em PHP e iOS é igualmente disputada.

Porém, para cada vaga com JavaScript, são apenas 0,6 desenvolvedores JavaScript. É um mercado sedento por desenvolvedores com habilidade em JavaScript.

Fator nº 2: Buscas de longo prazo

Em média, um projeto em JavaScript recebe duas vezes mais pull requests do que um projeto em Java, Python ou Ruby. Em cima disso, o JavaScript está crescendo mais rápido do que qualquer outra linguagem popular.

O ecossistema do JavaScript também se beneficia de um investimento pesado de dinheiro e engenharia de empresas como Google, Microsoft, Facebook e Netflix.

Por exemplo, o TypeScript (um superset estaticamente tipado do JavaScript) tem mais de 100 contribuintes open source, muitos deles são funcionários da Microsoft e do Google que são pagos para trabalhar nele.

Esse tipo de cooperação entre empresas é difícil de encontrar com o Java. A Oracle – que efetivamente é a dona do Java pela aquisição da Sun Microsystems – frequentemente processa empresas que tentam expandi-lo (texto em inglês).

Fator nº 3: Dificuldade de aprender

A maioria dos programadores concorda que linguagens de script de alto nível são fáceis de aprender. O JavaScript entra nessa categoria, junto com o Python e o Ruby.

Mesmo que as universidades continuem ensinando linguagens como Java e C++ como primeiras linguagens, elas são consideravelmente mais difíceis de aprender.

Fator nº 4: Projetos que você pode construir

É aqui que o JavaScript realmente brilha. Ele roda em qualquer dispositivo que tiver um navegador, diretamente no navegador. Você pode construir basicamente qualquer coisa com JavaScript e compartilhar por aí.

Por causa da onipresença do JavaScript, Jeff Atwood, co-fundador do Stack Overflow, cunhou sua – agora – famosa lei:

"Qualquer aplicação que puder ser escrita em JavaScript, acabará sendo escrita em JavaScript."

E a cada mês que passa (em inglês), a lei de Atwood continua forte.

O Java também prometeu em algum momento rodar em qualquer lugar. Você pode até se lembrar dos Java Applets (em inglês) que a Oracle oficialmente descontinuou no começo desse ano.

O Python sofre muito com os mesmos problemas:

"Como eu posso dar esse jogo que eu fiz para um amigo? Melhor ainda, existe uma maneira de colocá-lo no meu celular e então mostrar para as outras crianças na escola sem eles terem que instalar? Hm." — James Hague, em Retiring Python as a Teaching Language (em inglês)

Para contrastar, aqui estão alguns apps que os membros da nossa comunidade open source construiu nos seus navegadores usando o CodePen. Você pode clicar e começar a usar agora mesmo no seu navegador:

Aprenda bem uma linguagem. Depois aprenda uma segunda.

Se você continua pulando de linguagem para linguagem, você não vai chegar longe (texto em inglês).

Para sair do básico, você precisa aprender bem a sua primeira linguagem.‌‌ Depois, sua segunda linguagem será muito, muito fácil.

A partir daí, você pode aprender outra e outra linguagem, e se tornar uma pessoa desenvolvedora mais completa por aprender várias linguagens:

• C é uma ótima maneira de aprender como computadores realmente funcionam em termos de gerenciamento de memória, e é superútil em computação de alto desempenho.
• C++ é ótimo para desenvolvimento de jogos.
• Python é maravilhoso para ciência e estatísticas.
• Java é importante se você quiser trabalhar em empresas de tecnologia de grande escala.

Ainda assim, aprenda JavaScript primeiro.

OK, agora vou tentar algo impossível – vou tentar antecipar as objeções dos comentários dos leitores.

Objeção nº 1: Mas o JavaScript não é lento?

O JavaScript é — para a maioria dos propósitos — tão rápido quando as linguagens de alto desempenho.

O JavaScript (na forma do Node.js) é, em ordens de magnitude, mais rápido que o Python, Ruby e PHP.

Ele é também quase tão rápida quanto as linguagens de alto desempenho, como o C++, o Java e o Go.

Abaixo estão os resultados de benchmark (comparação) das linguagens:

Objeção nº 2: Mas JavaScript não é estaticamente tipado

Como o Python e o Ruby, o JavaScript é dinamicamente tipado, o que é conveniente. Ele, porém pode colocar você em maus lençóis. Aqui, eu pretendo, por exemplo, que o exampleArray seja um array. Eu configurei seus valores e verifiquei seu tamanho – que é o número de elementos que o array contém dentro dele.

exampleArray = [1, 2]
-> [1, 2]

exampleArray.length
-> 2

Acidentalmente, porém, eu reatribuí o valor dele para uma string.

exampleArray = "text"
-> "text"

exampleArray.length
-> 4

Esses tipos de erros acontecem o tempo todo em linguagens dinamicamente tipadas. A maioria dos desenvolvedores apenas colocam verificações para evitá-los e escreve os testes de acordo.

Se você realmente precisa de tipagem estática na sua primeira linguagem de programação, então, eu continuo recomendando que você aprenda JavaScript primeiro. Depois, você poderá aprender rapidamente o TypeScript.

"O Typescript tem uma curva de aprendizado, mas se você já sabe JavaScript, será uma curva tranquila." — Alex Ewerlöf, sobre o TypeScript (em inglês)

Objeção nº 3: Mas eu quero construir uma aplicação para dispositivos móveis

Eu continuo recomendando o JavaScript primeiro.

1. O JavaScript tem várias ferramentas para fazer aplicações para dispositivos móveis, como o Angular Cordova e o ReactNative.
2. Para a sua aplicação para dispositivos móveis realmente fazer algo interessante, ela provavelmente precisará de um back-end decente, que você desejará construir com um framework de desenvolvimento web, como o Node.js + Express.js.

Além disso, vale ressaltar que os melhores dias do desenvolvimento de aplicações para dispositivos móveis podem muito bem estar por vir.

Para começo de conversa, por mais que as pessoas usem aplicações para dispositivos móveis, quase metade de todos os trabalhos de desenvolvedor são para o desenvolvimento web. Compare isso com meros 8% dos trabalhos que envolvem o desenvolvimento de aplicações para dispositivos móveis.

A grande visão de "há um aplicativo para isso" não se concretizou. Em vez disso, a maioria dos proprietários de smartphones parou de baixar novos aplicativos (texto em inglês).

Claro – eles continuam usando aplicativos. Na maioria, o Facebook, Google Maps e vários outros. Então, a maioria da demanda por desenvolvedores de aplicações para dispositivos móveis está concentrada em alguns grandes empregadores.

As perspectivas para esses empregos de desenvolvimento para dispositivos móveis são difíceis de prever. Muitos aspectos do desenvolvimento, manutenção e de distribuição de aplicações para dispositivos móveis são fáceis com JavaScript. Então, empresas como o Facebook e o Google estão investindo pesado em ferramentas melhores para construir essas aplicações usando o JavaScript.

A partir de 2016, grande parte do desenvolvimento passou a ser de desenvolvimento web. Tudo que toca aquela grande plataforma é "a web". A próxima onda de dispositivos com os quais você conversará em sua casa, e os carros que pegam os seus filhos na escola – todos eles serão conectados usando a web também.

Isso significa usar o JavaScript.

Objeção nº 4: o JavaScript não é uma linguagem de brincadeirinha que foi escrita em 10 dias?

O JavaScript tem uma história peculiar (em inglês).

Você, sem dúvida, ouvirá as pessoas fazerem piadas às suas custas.

Bem, as pessoas também adoram odiar o C++. Assim como o JavaScript, o C++ teve sucesso apesar desse ódio – e agora está em praticamente todos os lugares também.

Então, se alguém encrencar com você ao aprender JavaScript em vez da linguagem de elite dessa semana, lembre-se das famosas palavras do criador do C++:

"Existem apenas dois tipos de linguagens de programação: aquelas das quais as pessoas sempre reclamam e aquelas que ninguém usa." — Bjarne Stroustrup

Eu escrevo apenas sobre programação e tecnologia. Se você me seguir no Twitter, garanto que não estará perdendo seu tempo.

Neste artigo, eu vou mostrar para você como fazer um NFT sem nenhuma habilidade em engenharia de software. Depois, vamos aprender como fazer NFTs customizáveis ilimitados com o Brownie, Python e o Chainlink (todos os links em inglês). Então, veremos como renderizar e vender nossa criação no Marketplace de NFTs da OpenSea.

Se estiver procurando por um tutorial que use o Truffle, JavaScript e alguns personagens medievais legais, dê uma olhada em como Construir, Implantar e Vender seu NFT aqui (em inglês).

O que é um NFT?

NFTs (do inglês non-fungible tokens, ou  "tokens não fungíveis") podem ser resumidos em uma palavra: "únicos".  Eles são contratos inteligentes implantados em uma blockchain que representam algo único.

ERC20 x ERC721

NFTs são tokens padrão de blockchain, similares ao ERC20 (em inglês), como AAVE, SNC e LINK (tecnicamente, um ERC677). ERC20s são tokens "fungíveis" o que significa que são "substituíveis" ou "intercambiáveis".

Por exemplo, a nota de dez reais vai valer R$ 10,00, não importando qual nota você use, desde que ela seja uma nota de dez reais. O código na nota pode até ser diferente, mas as notas são intercambiáveis e elas vão valer dez reais independentemente de outras coisas.

NFTs, por outro lado, são "não fungíveis". Eles seguem seu próprio padrão de token, o ERC721. Por exemplo, a Mona Lisa é "não fungível". Mesmo que alguém faça uma cópia dela, sempre vai haver apenas uma Mona Lisa. Se a Mona Lisa tivesse sido criada em uma blockchain, ela seria um NFT.

Para que serve um NFT?

NFTs agregam valor para os criadores, artistas, designers de jogos e outros por terem um histórico permanente de implantação armazenado on-chain.

Você sempre saberá quem criou o NFT, quem o comprou, de onde ele veio e mais, o que dá a eles muito valor, mais do que arte tradicional. Na arte tradicional, pode ser bem difícil discernir o que é falso, enquanto um histórico on-chain é facilmente rastreável.

Como os contratos inteligentes e os NFTs são 100% programáveis, NFTs podem também ter royalties e qualquer outra funcionalidade embutida. Recompensar os artistas sempre foi um problema, dado que um trabalho artístico geralmente é apresentado sem nenhuma atribuição, como ouvir uma música no parque.

Mais e mais artistas e engenheiros estão aproveitando desse valor agregado, porque finalmente é uma boa maneira de recompensar os artistas por seu trabalho. Mais que isso, os NFTs são maneiras divertidas de botar para quebrar com sua criatividade e se tornar um colecionador em um mundo digital.

O valor dos NFTs

Os NFTs percorreram um longo caminho e continuamos vendo recordes de vendas de NFTs, como "Everydays: The First 5.000 Days" sendo vendido por US$ 69,3 milhões.

Então, existe um grande valor aqui, além de ser divertido, dinâmico e uma forma engajadora de criar arte em um mundo digital e aprender sobre criação de um contrato inteligente. Agora, eu vou ensinar a você tudo o que precisa saber sobre criar NFTs.

Como criar um NFT

O que não vamos ensinar

A maneira mais fácil de fazer um NFT é ir a uma plataforma, como a Opensea, a Rarible ou a Mintible, e seguir o seu passo a passo para a implantação na plataforma escolhida.

Você pode seguir por esse caminho. No entanto, você pode acabar ligado à plataforma de alguma forma e ficará preso na funcionalidade que a plataforma tiver. Desse modo, você não poderá alcançar a personalização ilimitada nem utilizar realmente qualquer uma das vantagens que os NFTs têm. Mas se você for um engenheiro de software principiante, ou se não for muito técnico, esse caminho servirá para você.

Se você procura se tornar um engenheiro de software melhor, aprender um pouco sobre Solidity e ter o poder de criar algo com criatividade ilimitada, siga com a leitura!

Se você é novo com Solidity, não se preocupe. Também passaremos pelo básico.

Como criar um NFT com customização Ilimitada

Vamos começar com o NFT Brownie Mix. Esse é um repositório em desenvolvimento com muito código boilerplate.

Pré-requisitos

Precisaremos de alguns programas instalados antes de começar

• Python
• Nodejs e npm
• Metamask

Se você não está familiarizado com o Metamask, você pode seguir esse tutorial (em inglês) para configurá-lo.

Rinkeby Testnet ETH e LINK

Estaremos trabalhando também com o Rinkeby Ethereum Testnet para realizar a implantação dos nossos contratos em uma blockchain real, de graça!

Testnets são formas excelentes de testar como os contratos se comportam no mundo real.

Precisaremos do Rinkeby ETH e do Rinkeby LINK, que conseguimos gratuitamente nos links da documentação do Chainlink (em inglês)

Também precisaremos adicionar o token do Rinkeby LINK na nossa metamask, o que podemos fazer seguindo a documentação de como conseguir o LINK (em inglês).

Se você continuar confuso, você pode usar este vídeo como guia (em inglês), apenas certifique-se de usar o Rinkerby ao invés do Ropsten.

Quando trabalhamos com uma plataforma de contratos inteligentes, como a Ethereum, precisamos pagar um pouco de ETH. Quando retiramos dados off-chain precisamos pagar com um pouco de LINK. Por este motivo, nós precisamos dos testnets Link e ETH.

Maravilha, agora vamos mergulhar. Este é o NFT que vamos implantar na OpenSea.

Começando

git clone https://github.com/PatrickAlphaC/nft-mix
cd nft-mix

Ótimo! Agora, precisamos instalar o ganache-cli e o eth-brownie.

pip install eth-brownie
npm install -g ganache-cli

Então, podemos configurar nossas variáveis de ambiente (em inglês). Se você não é familiarizado com variáveis de ambiente, pode apenas adicioná-las no seu arquivo .env e executar:

source .env

Deve existir um arquivo .env no repositório que você acabou de clonar com as variáveis de ambiente comentadas. Retire-as dos comentários para usá-las!

Você vai precisar de um WEB3_INFURA_PROJECT_ID e de uma PRIVATE_KEY. O WEB3_INFURA_PROJECT_ID pode ser encontrado ao se cadastrar com uma conta gratuita no Infura. Assim, teremos uma maneira de enviar as transações para a blockchain.

Também vamos precisar de uma private key, que você consegue pegar em sua Metamask. Clique nos 3 pontinhos, vá em Account Details e depois em Export Private Key. NÃO compartilhe essa chave com ninguém se você colocar dinheiro de verdade nela!

export PRIVATE_KEY=YOUR_KEY_HERE
export WEB3_INFURA_PROJECT_ID=YOUR_PROJECT_ID_HERE

Agora, podemos implantar nosso contrato NFT e criar nosso primeiro colecionável com os dois comandos a seguir.

brownie run scripts/simple_collectible/deploy_simple.py --network rinkeby
brownie run scripts/simple_collectible/create_collectible.py --network rinkeby

O primeiro script implanta nosso contrato NFT na blockchain da Rinkerby, e o segundo cria nosso colecionável.

Você acabou de implantar seu primeiro contrato inteligente!

Por enquanto, ele não faz muita coisa, mas não se preocupe – vou mostrar para você como renderizá-lo na OpenSea na parte avançada desse tutorial. Mas, antes, vamos olhar para o padrão de token ERC721.

O padrão de token ERC721

Vamos dar uma olhada no contrato que acabamos de implantar no arquivo SimpleCollectible.sol.

// SPDX-License-Identifier: MIT
pragma solidity 0.6.6;

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

contract SimpleCollectible is ERC721 {
    uint256 public tokenCounter;
    constructor () public ERC721 ("Dogie", "DOG"){
        tokenCounter = 0;
    }

    function createCollectible(string memory tokenURI) public returns (uint256) {
        uint256 newItemId = tokenCounter;
        _safeMint(msg.sender, newItemId);
        _setTokenURI(newItemId, tokenURI);
        tokenCounter = tokenCounter + 1;
        return newItemId;
    }

}

Estamos usando o pacote OpenZeppelin (em inglês) para o token ERC721. Esse pacote que importamos nos permite usar todas as funções típicas de um token ERC721. Isso define todas as funcionalidades que nossos tokens vão ter, como transfer, que move tokens para novos usuários, safeMint que cria novos tokens e mais.

Você pode encontrar todas as funções que são fornecidas ao nosso contrato lendo o Contrato de Token ERC721 OpenZeppelin. Nosso contrato herda essas funções nessa linha:

contract SimpleCollectible is ERC721 {

É assim que a Solidity trabalha com herança. Quando nós implantamos um contrato, o constructor é automaticamente chamado e recebe alguns parâmetros.

constructor () public ERC721 ("Dogie", "DOG"){
        tokenCounter = 0;
    }

Também usamos o construtor do ERC721 no nosso construtor. Temos que dar a ele um nome e um símbolo. No nosso caso, é "Dogie"e "DOG". Isso significa que todos os NFTS criados serão do tipo Dogie/DOG.

É como todos os Pokémons nas cartas de pokémons. Eles no final são pokémons, ou todo jogador de baseball nas cartas colecionáveis (trading cards) continuam jogadores de baseball. Cada jogador é único, mas eles continuam sendo jogadores de baseball. Nós estamos apenas usando o tipo DOG.

Nós temos um tokenCounter no topo que conta quantos NFTs já criamos daquele tipo. Cada novo token ganha um tokenId baseado no tokenCounter atual.

Atualmente, nós podemos criar um NFT com a função createCollectible. É ela que chamamos no nosso script create_collectible.py.

function createCollectible(string memory tokenURI) public returns (uint256) {
        uint256 newItemId = tokenCounter;
        _safeMint(msg.sender, newItemId);
        _setTokenURI(newItemId, tokenURI);
        tokenCounter = tokenCounter + 1;
        return newItemId;
    }

A função _safeMint cria o novo NFT e o atribui a quem chamou createdCollectible, também conhecido comomsg.sender, com um newItemId derivado de tokenCounter. É assim que podemos acompanhar quem é proprietário de quê, verificando o proprietário do tokenId.

Você vai perceber que também chamamos a função _setTokenURI. Vamos conversar sobre ela.

O que são metadados de NFT e tokenURI?

Quando os contratos inteligentes estavam sendo criados e os NFTs estavam sendo criados, as pessoas rapidamente perceberam que é beeeeeem caro implantar muitos dados na blockchain. Imagens pequenas de um KB podem facilmente custar mais de 1 milhão de dólares para guardar (em inglês).

Isso é claramente um problema para os NFTs, já que, ao ser o proprietário de arte criativa, você tem que guardar essa informação em algum lugar. Eles também queriam uma maneira mais leve de guardar os atributos sobre NFTs – e é aqui que  os metadados e o tokenURI entram em ação.

TokenURI

O tokenURI em um NFT é um identificador único da "aparência" daquele token. Um URI pode ser uma chamada HTTPS para uma API, um hash IPFS, ou qualquer outra coisa exclusiva.

Eles seguem um padrão de mostrar os metadados que têm essa aparência:

{
    "name": "name",
    "description": "description",
    "image": "https://ipfs.io/ipfs/QmTgqnhFBMkfT9s8PHKcdXBn1f5bG3Q5hmBaR4U6hoTvb1?filename=Chainlink_Elf.png",
    "attributes": [
        {
            "trait_type": "trait",
            "value": 100
        }
    ]
}

Eles mostram como um NFT é e seus atributos. O atributo image aponta para outro URI da aparência do NFT. Isso facilita para as plataformas de NFT como a Opensea, Rarible e Mintable renderizar NFTs nas suas plataformas, já que todos estão esperando receber esses metadados.

Metadados off-chain x metadados on-chain

Agora, você pode estar pensando "Peraí... se os metadados não estão on-chain, significa que o meu NFT pode sumir em algum momento"? E você não poderia estar mais correto.

Você também estaria correto em pensar que metadados off-chain significam que você não pode usá-los para que seus contratos inteligentes interajam um com o outro.

Esse é o motivo pelo qual nós queremos focar nos metadados on-chain, para que assim possamos programar nossos NFTs para interagir uns com os outros.

No entanto, ainda precisamos da parte da imagem (image) dos metadados off-chain, pois não temos uma maneira otimizada de armazenar imagens grandes on-chain. Mas não se preocupe. Podemos fazer isso gratuitamente em uma rede descentralizada ainda usando IPFS.

Aqui está um exemplo de um imageURI do IPFS que mostra o Chainlink Elf criado no tutorial Dungeons and Dragons (em inglês).

Não definimos um tokenURI para o NFT simplesmente porque queríamos apenas mostrar um exemplo básico.
Vamos pular para o NFT avançado agora, para que possamos ver alguns dos recursos incríveis que podemos fazer com metadados on-chain, para que o NFT seja renderizado na Opensea, e colocar nosso Dogie no ar!

Se você quiser um vídeo para refrescar sua memória sobre o que acabamos de ver na seção anterior, acompanhe esse vídeo sobre a implantação de um NFT simples.

NFTs dinâmicos e avançados

NFTs dinâmicos são NFTs que podem mudar com o tempo ou ter funcionalidades on-chain que podem ser usadas para interagir umas com as outras. Esses são as NFTs que tem customizações ilimitadas. Assim, podemos criar jogos inteiros, mundos ou algum tipo de arte interativa.
Vamos nos aprofundar na parte avançada desse tutorial.

Início rápido avançado

Certifique-se de ter as testnets ETH e LINK, bem como o suficiente na sua metamask, e então execute o comando a seguir:

brownie run scripts/advanced_collectible/deploy_advanced.py --network rinkeby
brownie run scripts/advanced_collectible/create_collectible.py --network rinkeby

Nosso collectible aqui é uma reprodução de raças de cachorros aleatória retornada do Chainlink VRF (em inglês). Chainlink VRF é uma maneira de obter números aleatórios comprováveis e, portanto, realmente em falta em nossos NFTs. Em seguida, vamos criar seus metadados.

brownie run scripts/advanced_collectible/create_metadata.py --network rinkeby

Podemos, então, como opção, fazer upload desses dados para o IPFS para que possamos ter um tokenURI. Eu vou mostrar para você como fazer isso mais tarde. Por enquanto, vamos usar apenas o tokenURI de exemplo de:

https://ipfs.io/ipfs/Qmd9MCGtdVz2miNumBHDbvj8bigSgTwnr4SbyH6DNnpWdt?filename=1-PUG.json

Se você fizer o download do IPFS Companion no seu navegador, poderá usar aquele URL para ver o que o URI retorna. Ficará parecido com isso:

{
    "name": "PUG",
    "description": "An adorable PUG pup!",
    "image": "https://ipfs.io/ipfs/QmSsYRx3LpDAb1GZQm7zZ1AuHZjfbPkD6J7s9r41xu1mf8?filename=pug.png",
    "attributes": [
        {
            "trait_type": "cuteness",
            "value": 100
        }
    ]
}

Então, podemos executar nosso script set_tokenuri.py:

brownie run scripts/advanced_collectible/set_tokenuri.py --network rinkeby

Teremos, então, uma saída como esta:

Running 'scripts/advanced_collectible/set_tokenuri.py::main'...
Working on rinkeby
Transaction sent: 0x8a83a446c306d6255952880c0ca35fa420248a84ba7484c3798d8bbad421f88e
  Gas price: 1.0 gwei   Gas limit: 44601   Nonce: 354
  AdvancedCollectible.setTokenURI confirmed - Block: 8331653   Gas used: 40547 (90.91%)

Awesome! You can view your NFT at https://testnets.opensea.io/assets/0x679c5f9adC630663a6e63Fa27153B215fe021b34/0
Please give up to 20 minutes, and hit the "refresh metadata" button

E podemos clicar no link que nos foi dado para ver como ficou no Opensea! Talvez você tenha que clicar no botão refresh metadata e esperar alguns minutos.

As raças aleatórias

Vamos falar sobre o que acabamos de fazer. Aqui está nossa AdvancedCollectible.sol:

pragma solidity 0.6.6;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@chainlink/contracts/src/v0.6/VRFConsumerBase.sol";

contract AdvancedCollectible is ERC721, VRFConsumerBase {
    uint256 public tokenCounter;
    enum Breed{PUG, SHIBA_INU, BRENARD}
    // add other things
    mapping(bytes32 => address) public requestIdToSender;
    mapping(bytes32 => string) public requestIdToTokenURI;
    mapping(uint256 => Breed) public tokenIdToBreed;
    mapping(bytes32 => uint256) public requestIdToTokenId;
    event requestedCollectible(bytes32 indexed requestId); 


    bytes32 internal keyHash;
    uint256 internal fee;
    uint256 public randomResult;
    constructor(address _VRFCoordinator, address _LinkToken, bytes32 _keyhash)
    public 
    VRFConsumerBase(_VRFCoordinator, _LinkToken)
    ERC721("Dogie", "DOG")
    {
        tokenCounter = 0;
        keyHash = _keyhash;
        fee = 0.1 * 10 ** 18;
    }

    function createCollectible(string memory tokenURI, uint256 userProvidedSeed) 
        public returns (bytes32){
            bytes32 requestId = requestRandomness(keyHash, fee, userProvidedSeed);
            requestIdToSender[requestId] = msg.sender;
            requestIdToTokenURI[requestId] = tokenURI;
            emit requestedCollectible(requestId);
    }

    function fulfillRandomness(bytes32 requestId, uint256 randomNumber) internal override {
        address dogOwner = requestIdToSender[requestId];
        string memory tokenURI = requestIdToTokenURI[requestId];
        uint256 newItemId = tokenCounter;
        _safeMint(dogOwner, newItemId);
        _setTokenURI(newItemId, tokenURI);
        Breed breed = Breed(randomNumber % 3); 
        tokenIdToBreed[newItemId] = breed;
        requestIdToTokenId[requestId] = newItemId;
        tokenCounter = tokenCounter + 1;
    }

    function setTokenURI(uint256 tokenId, string memory _tokenURI) public {
        require(
            _isApprovedOrOwner(_msgSender(), tokenId),
            "ERC721: transfer caller is not owner nor approved"
        );
        _setTokenURI(tokenId, _tokenURI);
    }
}

Usamos o Chainlink VRF para criar uma raça aleatória de uma lista de PUG, SHIBA_INU, BERNARD. Quando chamamos a createCollectible desta vez, na verdade ,iniciamos uma solicitação para o nó Chainlink VRF off-chain e retornamos com um número aleatório para criar o NFT com uma dessas 3 raças.

Usar aleatoriedade verdadeira em seus NFTs é uma ótima maneira de criar escassez verdadeira e usar um número aleatório do oráculo Chainlink significa que seu número é comprovadamente aleatório, não podendo ser influenciado pelos mineradores.

Você pode aprender mais sobre isso na documentação do Chainlink VRF(em inglês).

O nó Chainlink responde chamando a função fulfillRandomness e cria o collectible com base no número aleatório. Ainda temos que chamar _setTokenURI para dar ao nosso NFT a aparência que ele precisa.

Nós não demos nossos atributos do NFT aqui, mas os atributos são uma ótima maneira de fazer com que nossos NFTs batalhem e interajam. Você pode ver um ótimo exemplo de NFTs com atributos neste exemplo de Dungeons and Dragons (em inglês).

Metadados do IPFS

Estamos usando o IPFS para guardar dois arquivos:

1. A imagem do NFT (a imagem do pug)
2. O arquivo tokenURI (o arquivo JSON que também inclui o link da imagem)

Nós usamos o IPFS por ser uma plataforma grátis e descentralizada. Também podemos adicionar nossos tokenURIs e imagens no IPFS fazendo download do IPFS desktop (em inglês), clicando no botão import.

Agora, podemos compartilhar o URI clicando nos três pontos ao lado do arquivo que queremos compartilhar, clicando em share link e copiando o link fornecido. Podemos adicionar esse link no nosso arquivo set_tokenuri.py para mudar o URI do token que queremos usar.

Persistência

No entanto, se o tokenURI estiver apenas em nosso node, isso significa que, quando nosso node estiver inativo, ninguém mais poderá visualizá-lo. Então, queremos que outros façam o pin do nosso NFT. Podemos usar um serviço que realiza o pin como o Pinata para ajudar a manter nossos dados ativos mesmo quando nosso node no IPFS estiver inativo.

Imagino que, no futuro, mais e mais metadados serão armazenados em IPFS e plataformas de armazenamento serão descentralizadas. Servidores centralizados podem ficar inativos, e isso significaria que a arte dos NFTs nesses servidores seria perdida para sempre. Certifique-se de verificar onde está localizado o tokenURI do NFT que você usa!
Também espero que mais pessoas usem plataformas dStorage como Filecoin, pois usar um serviço de pinning também não é tão descentralizado quanto deveria ser.

Indo além

Se você quiser ver um passo a passo em vídeo do NFT avançado que acabamos de fazer, assista ao vídeo sobre NFT avançado.

Agora, você tem as habilidades para criar NFTs lindos, divertidos, personalizados e interativos e renderizá-los em um marketplace.

NFTs são maneiras divertidas e poderosas de compensar os artistas com precisão por todo o trabalho duro que eles fazem. Boa sorte e lembre-se de se divertir!

O comando básico para enviar um push de uma branch local para um repositório remoto é o git push.

Esse comando tem uma variedade de opções e parâmetros que podem ser passados a ele. Neste artigo, você aprenderá aqueles que você mais usará no dia a dia.

Como fazer o push de uma branch local para a branch origin

Se você executar o comando git push, o Git por padrão escolherá dois parâmetros a mais para você: o repositório remoto para realizar o push e a branch do push.

A forma genérica do comando é esta:

$ git push <remote> <branch>

Por padrão, o Git escolhe a origin como repositório remoto e sua branch atual como a branch para o push.

Se a sua branch atual é a main, o comando git push vai completar os outros dois parâmetros pré-definidos – executando, efetivamente, git push origin main.

No exemplo abaixo, origin  é um repositório remoto no GitHub. A branch atual é a main:

(main)$ git remote -v 
origin  git@github.com:johnmosesman/burner-repo.git (fetch)
origin  git@github.com:johnmosesman/burner-repo.git (push)

(main)$ git push
Enumerating objects: 4, done.
Counting objects: 100% (4/4), done.
Delta compression using up to 16 threads
Compressing objects: 100% (2/2), done.
Writing objects: 100% (3/3), 274 bytes | 274.00 KiB/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To github.com:johnmosesman/burner-repo.git
   b7f661f..ab77dd6  main -> main

Na saída da execução, você verá que a branch local main foi enviada para a branch remota main:

To github.com:johnmosesman/burner-repo.git
   b7f661f..ab77dd6  main -> main

Como forçar o push de uma branch no Git

Normalmente, você realizará um push para uma branch e essa ação será adicionada ao seu histórico de commits.

Existem, no entanto, situações em que você precisará sobrescrever de forma forçada o histórico de uma branch.

Existem alguns motivos para você precisar fazer isso.

O primeiro motivo é consertar um erro – apesar de que, provavelmente, seria melhor apenas fazer um novo commit, revertendo as mudanças.

O segundo motivo é um cenário mais comum. Após uma ação do tipo rebase (texto em inglês) que altera o histórico de commits:

Internamente, o Git realiza [um rebase] criando novos commits e aplicando-os à base especificada. É muito importante entender que, apesar de a branch parecer a mesma, ela é composta de commits inteiramente novos.

O rebase cria commits inteiramente novos.

Isso significa que, se você tentar fazer o push de uma branch que sofreu rebase localmente – nas que não se encontra na branch remota – o repositório remoto vai reconhecer que o histórico de commits foi alterado e vai evitar que você faça o push enquanto não resolver as diferenças:

(my-feature)$ git push
To github.com:johnmosesman/burner-repo.git
 ! [rejected]        my-feature -> my-feature (non-fast-forward)
error: failed to push some refs to 'git@github.com:johnmosesman/burner-repo.git'
hint: Updates were rejected because the tip of your current branch is behind
hint: its remote counterpart. Integrate the remote changes (e.g.
hint: 'git pull ...') before pushing again.
hint: See the 'Note about fast-forwards' in 'git push --help' for details.

Você poderia usar o comando git pull para fazer o merge das diferenças, mas se realmente quiser sobrescrever o repositório remoto, você pode adicionar a flag --force no seu comando push:

(my-feature)$ git push --force origin my-feature
Enumerating objects: 1, done.
Counting objects: 100% (1/1), done.
Writing objects: 100% (1/1), 184 bytes | 184.00 KiB/s, done.
Total 1 (delta 0), reused 0 (delta 0)
To github.com:johnmosesman/burner-repo.git
 + edb64e2...52f54da my-feature -> my-feature (forced update)

Observação: você pode usar apenas -f ao invés de --force, para abreviar.

Um push forçado é uma ação destrutiva – use-a somente quando tiver certeza de que é isso mesmo que você quer fazer.

Force push com lease

Talvez você queira fazer um force push – mas só se ninguém tiver contribuído para a branch.

Se mais alguém contribuiu para sua branch e se tiver feito um push para o repositório remoto – e se você fizer um force push – você vai sobrescrever todas as mudanças que foram feitas por outros.

Para prevenir esse tipo de problema, você pode usar a opção --force-with-lease.

Novamente, pela documentação:

--force-with-lease sozinho, sem especificar os detalhes, protegerá todas as refs remotas que serão atualizadas, exigindo que o seu valor atual seja o mesmo que o da branch monitorada remotamente que temos para elas.

Basicamente, você está dizendo ao Git para forçar a atualização dessa branch apenas se ela for exatamente igual ao que era da última vez que você a viu.

Se você estiver colaborando com outras pessoas na sua branch, é recomendado não usar a flag --force ou, ao menos, usar a opção --force-with-lease para prevenir a perda de mudanças que outros colaboradores tenham feito.

Como fazer um push para uma branch com um nome diferente no Git

Você normalmente fará o push da sua branch local para uma branch remota com o mesmo nome – mas nem sempre.

Para fazer um push para uma branch com o nome diferente, você vai precisar especificar a branch da qual você deseja fazer o push e a branch para qual você fará o push, separadas por dois-pontos (:).

Por exemplo, se você quer fazer um push de uma branch chamada some-branch para outra chamada my-feature:

(some-branch)$ git push origin some-branch:my-feature
Total 0 (delta 0), reused 0 (delta 0)
To github.com:johnmosesman/burner-repo.git
 + 728f0df...8bf04ea some-branch -> my-feature

Como fazer um push de todas as branches locais para um repositório remoto

Você não precisa fazer um push de todas as suas branches locais sempre, mas, se precisar, pode adicionar a flag --all:

(main)$ git branch
* main
  my-feature

(main)$ git push --all
...
To github.com:johnmosesman/burner-repo.git
   b7f661f..6e36148  main -> main
 * [new branch]      my-feature -> my-feature

Conclusão:

O comando git push é um dos comandos que você mais usará. Existem várias opções que podem ser usadas com ele. Recomendo fortemente que você leia a documentação para encontrar outras opções úteis e atalhos.

Se você gostou desse tutorial, o autor também fala sobre tópicos desse tipo no Twitter, além de escrever mais sobre o assunto no seu site (em inglês).