DEV Community: Nick Groos

Blockchain with Solidity: What to Learn First

Nick Groos — Wed, 12 May 2021 14:34:49 +0000

Getting started in a blockchain development environment can feel completely foreign, especially if you are coming from web development.

Here is an overview of some key items I had to learn about in my first few days with Solidity:

Web3

Web3 is a term you will see often. In broad terms, it refers to certain interfaces and tools that make it easy to integrate with crypto wallets (like Metamask) and other blockchain-related functionality. There are a growing number of libraries that expose Web3 functionality in different dev environments.

Metamask

Metamask is currently the standard browser-based wallet to use while learning blockchain development. It has built-in integration with IDE and Testnet environments (more on this below) which makes it easy to acquire and use test Ether.

Gas

You have to pay gas (ether) to "change" the blockchain. This includes making a payment transaction, updating the state of a smart contract, or deploying a smart contract.
Consider your gas payment to be the transaction fee paid to the miners running the network
Your Solidity code should be optimized to reduce gas cost.

Remix and Hardhat

Remix is an online IDE for compiling and deploying contracts written in Solidity. It is the quickest way to start working with smart contracts.
Hardhat is a framework for doing blockchain development in a local environment. It can also deploy to live and testnet environments.

Testnets and Testnet Faucets

Testnets are test blockchain environments. Use them to deploy and test smart contracts without having to spend real crypto on gas.
Testnet Faucets will send cryptocurrency to your Metamask wallet which can be used on the Testnet environments.
- Kovan
- Ropsten
- Rinkeby

ERC-20

This is a spec for implementing fungible tokens. Read about it here

ERC-721

This is a spec for implementing non-fungible tokens. Read about it here

I hope this list can save some time for anyone else out there learning Solidity. Let me know in the comments if there is something you think I should add.

Why are you using 'git pull' ?

Nick Groos — Mon, 10 May 2021 16:54:11 +0000

I have noticed that for whatever reason, new developers love to use git pull for merging code. To get latest from another branch, they will do something like this:

Switch to the other branch
git pull the latest code for that branch
Switch back to the working branch
Merge the freshly pulled code into the working branch

So, git pull can get the job done. And developers will go months or years unaware of the much more nimble git fetch.

The problem is that the steps above require us to switch branches, a slow git operation, two times. We can achieve the same outcome without switching branches by using git fetch:

git fetch origin develop
git merge origin/develop

And we have the latest from /develop into our current working branch.

The seemingly small efficiency gained from a workflow that uses git fetch instead of git pull will result in hours of saved time over the course of a project.

For more context I recommend this discussion about 'git fetch' vs 'git-pull'

Non-ASCII characters in Azure metadata fields

Nick Groos — Wed, 17 Jun 2020 13:54:35 +0000

Azure Blob Storage and Azure Search - Handling non-ASCII characters with Azure Indexers

Azure Blob Containers will only accept ASCII characters in metadata fields. In order to store a character like "ó" in your metadata fields, URL encode the metadata before writing to Azure:

title: encodeURIComponent(docTitle),

The encoded data will look like "%C3%B3" to preserve the non-ASCII characters. Simply decode before displaying on the front end.

But what if my metadata needs to be searchable in Azure Search?

I pushed the above change to production, and it broke our search page. Special characters were not searchable because there were no special characters in the search index (they were encoded). And encoding the search queries before executing a search just seemed like a bad idea.

Azure Indexers, which we used to get our data from the blob into the search index, allow you to configure field mapping functions to transform your data as you are adding it to the search index

"urlDecode" is one of these mapping functions. The configuration looks like this:

{
      "sourceFieldName": "title",
      "targetFieldName": "my_document_title",
      "mappingFunction": {
        "name": "urlDecode"
      }
}

Now the special characters are stored unencoded in the search index and ready to be searched.

One cool trick for your React props

Nick Groos — Sat, 13 Jun 2020 18:04:15 +0000

Here is a concise way to pass props that have the same name as the value being passed. Instead of:

<Component prop1={prop1} prop2={prop2}/>

The spread operator lets us use this cool syntax:

<Component {...{ prop1, prop2 }}/>

They can be combined too:

<Component {...{ prop1, prop2 }} prop3={prop3}/>

This syntax can look a little strange at first but should be quite clear once you see it a few times. Use with discretion for readability concerns.