There is a high demand for quality blockchain developers, and for good reason. The blockchain and ICO space has exploded in the past few years. More and more people are trying to get in and make a name for themselves in the field. But, in order to succeed, it is vital that they have a strong and sound team. Blockchain developers and, more specifically, Ethereum developers are the most critical part of the team.

So in this guide, we’re going to make your life easier. We will show you how to pinpoint and sift the best people from the crowd.

Before we hire ethereum developers, it’s important to know what kind of people we’re hiring.

What makes a perfect Ethereum developer?

Among ethereum developers’ virtuosity, the most important thing to know is what are the basic qualities that separate the best from the rest? Good developers must be more than just developers with blockchain coding skills. We’re not saying that just being familiar with coding isn’t valuable, but if you need the right developer to build an empire. So, what are some of the main qualities you’re looking for?

  • A firm belief in decentralization: These people believe that decentralization will save humanity. Traditional companies won’t hire these people because they believe that institutions like society, companies and governments shouldn’t be decentralized.
  • Master cryptography: Blockchain developers need to master cryptography economics. Cryptoeconomics, cryptography and economics are divided into two parts. That’s why great Ethereum developers should have a relentless curiosity about cryptography.
  • Mastering economics: The second half of crypto economics is “economics,” so professional developers should also have a good knowledge of economics and game theory mechanisms. If you are building a blockchain platform, the code should ensure that all participants are financially motivated.
  • Extremely curious: In order to have such a large knowledge base, these people are naturally curious. Most of these people stay up late at night using videos, forums, and wikis to learn about specific issues.

So, now we know the kind of person we’re looking for. That’s why it makes sense to start with some ethereum basics.

Why do we do this?

Because every Ethereum developer should be fully familiar with these concepts.

What is Ethereum?

This is the way the Ethereum site is defined:

  • Ethereum is a platform within a zone that runs smart contracts: applications that run entirely procedurally, without any possibility of downtime, censorship, fraud or third-party interference. These applications run on a custom blockchain, a very powerful shared global infrastructure that transfers value and embodies ownership of property.

But simply put, Ethereum plans to be the ultimate software platform of the future. If the future is decentralized and Dapps become commonplace, ethereum must be front and center.

While Bitcoin is the first application of blockchain technology, it is still just a currency. Ethereum brings the full range of applications that blockchain technology is capable of.

As Ethereum co-founder Dr. Gavin Wood said:

  • Bitcoin is first and foremost a currency; This is a special application of blockchain. But it is far from the only app. To give a past example of a similar situation, E-mail is a special use of the Internet and certainly helps popularize it, but there are many other applications.

How does Ethereum mining work?

As of now, Ethereum is using the same proof-of-work that Bitcoin is using. However, Ethereum soon plans to move to proof-of-stake, which they will use the Casper protocol to make.

So what’s the difference between proof of equity and proof of work? This is actually something you can ask people about that you might be interviewing for. It is absolutely vital to understand how proof of work and proof of interest work.

Proof of work: This is the protocol that most cryptocurrencies like Ethereum and Bitcoin have followed so far. This means that miners mine cryptocurrencies by “mining” them using dedicated hardware.

Proof of equity: This agreement will make the entire mining process virtual. In this system, we have validators instead of miners. The way it works is that, as a validator, you first have to bet on some of your Ethernet locks. Once that’s done, you’ll start validating blocks, which basically means that if you see any blocks you think can be attached to the blockchain, you can verify it by placing a bet. When the block is appended, you will receive a reward proportional to the percentage of your investment. However, if you bet on the wrong or malicious block, your stake will be taken away.

To achieve proof of equity, Ethereum will use the Casper consistency algorithm. At first, it will be a hybrid style system, where most transactions will still be proof of work and every 100 transactions will be proof of equity. In doing so, it will offer real-world testing and verification on the Ethereum platform. But what does this mean for Ethereum? What are the advantages of this agreement? Let’s take a look:

Advantages of proof of interest

  • Lower overall energy consumption and currency costs: Bitcoin miners around the world spend about $50,000 per hour on electricity. That’s $1.2 million a day, $36 million a month, or about $450 million a year! Just focus on the numbers and the amount of power wasted. By using proof of equity, you will completely virtualize the process and cut off all these costs.
  • No ASIC advantage: Since the whole process will be virtual, there will be no dependence on who has better equipment or ASICS.
  • Makes 51% attacks harder: 51% attacks occur when a group of miners gains more than 50% of the world’s scattering power. Proof of equity can counteract this attack.
  • No malicious verifier: Any verifier who has money locked up in the blockchain will ensure that they do not add any false or malicious blocks to the chain, as this means that they will be stripped of their entire equity investment.
  • Block creation: Faster to create updated blocks and the whole process.
  • Scalability: Making the blockchain scalable by introducing the concept of “sharding” (more on this later).

Although there have been various simple proof of entitlement exercises before, Casper differentiates itself from others in that it incentivizes honest miners and punishes dishonest ones. If you have placed your bet on a malicious block, the bet will be withdrawn. It will punish anyone who doesn’t follow the rules.

Here’s how Vitalik explains it:

  • Imagine 100 people sitting around a round table. A person has a stack of documents, each with a different transaction history. The first participant picked up a pen and signed one, which was then passed on to the next person who made a similar choice. If each participant signs the transaction history that most participants end up signing, each participant only gets $1. If you sign one page and later sign another one that you shouldn’t, your house will burn down. Then he added that it might be good motivation to sign correctly!

What is a smart contract?

Smart contracts are automated contracts. They execute automatically and write specific instructions to their code that execute under certain conditions.

You can learn more about smart contracts in our other articles.

Smart contracts are how tasks are done in the Ethereum ecosystem. When someone wants to accomplish a specific task in Ethereum, they sign a smart contract with one or more people.

Smart contracts are a series of instructions, written in the programming language Solidity, THAT work based on IFTTT logic (i.e. If-this-then-that logic). Basically, if the first set of instructions is completed, the next function is executed, and then the next function is executed and repeated until the contract ends.

The best way to understand this is to think of a vending machine. Each step you take is like the next step executing its own trigger. It’s kind of like a domino effect. So, let’s look at the steps you’ll take when interacting with a vending machine:

  • Step 1: You give the vending machine some money.
  • Step 2: Press the button corresponding to the desired product.
  • Step 3: When the product comes out, you put it away.

Now look at all these steps and think about it. If the previous step is not performed, will any of the other steps still work? Each of these steps is directly related to the previous step. There is another factor to consider, which is part of a smart contract. You can see that during the entire interaction with the vending machine, you (the requester) only work with the machine (the provider). There was absolutely no third party involved.

So, now, what happens if it happens in the Ethereum network?

Suppose you just bought something from a vending machine in the Ethereum network. What would the steps be?

  • Step 1: You give the vending machine some money, which is recorded by all the nodes in the Ethereum network, and the transaction is updated in the ledger.
  • Step 2: Press the button corresponding to the product you want and update the record in the Ethereum network and ledger.
  • Step 3: The product comes out and you collect it, which will be recorded by all nodes and ledgers.

Every transaction you make through a smart contract will be recorded and updated by the network. This is done because it makes everyone involved in the contract accountable for their actions. It neutralizes human malevolence by making every action visible to the entire web

Okay, so far we’ve covered what Ethereum is, what mining is, what smart contracts are. If your candidate can’t satisfactorily answer these questions, let them go in a split second. It’s not worth your time anymore.

Master smart contract code

Obviously, this should be the dish of all great developers. One way you can be sure you know a developer’s expertise is to have them explain how a particular contract works. Here we will show you two Solidity codes. You can run the code through them and ask them to break it down and explain to you what happens at each step.

Code Example 1

Code and explanation from Toptal.

Pragma solidity 0.4.18; import"./Vehicle.sol";


contract VehicleOwner {
    address public owner;
    mapping(bytes32 => address) public vehicles;

    event NewVehicleAdded(address indexed newVehicle, uint256 timestamp);

    function VehicleOwner() public {
        owner = msg.sender;
    }

    /**
    * @dev Throws if called by any account other than the owner.
    */
    modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }

    functioncreateNewVehicle(string model, string make, bytes32 vin) public onlyOwner { address newVehicle = new Vehicle(model, make, vin); vehicles[vin] = newVehicle; NewVehicleAdded(newVehicle, now); }}Copy the code

Let’s take a line by line look at what this code does.

Pragma Solidity 0.4.18

Analysis: Specifies the version of the compiler to use. Here it’s 0.4.18

2. Import “./ vehicle.sol “; *

Analysis: Import smart contracts used to represent new vehicles.

3. Code: Contract VehicleOwner {

Analysis: declare the owner’s contract.

4. The code:

address public owner;
mapping(bytes32 => address) public vehicles;
Copy the code

Analysis: This is where we flesh out the contract. The first variable calls the owner owner and represents the Ethereum that created any given instance of your VehicleOwner contract.

The second vehicle, called vehicles, will be used to store a list of vehicles owned by the owner by assigning their contract address to the vehicle identification number provided.

5. Code:

function VehicleOwner() public {
owner = msg.sender;
}
Copy the code

Analysis: what is the name of the function and contract? This is because this particular function is a constructor. Its only function is to specify the address from which the function is called as the contract owner.

6. Code:

modifier onlyOwner() {
require(msg.sender == owner);
_;
}
Copy the code

Analysis: Use this function modifier to ensure that only the contract owner can access the contract.

See _? This produces the body of the function to which the modifier modifier is applied later.

7. Code:

function createNewVehicle(string model, string make, bytes32 vin) public onlyOwner {
address newVehicle = new Vehicle(model, make, vin);
vehicles[vin] = newVehicle;
NewVehicleAdded(newVehicle, now);
}
Copy the code

Analysis: This creates a new contract on the blockchain, which represents a new vehicle. The constructor of the vehicle contract accepts three attributes: Model, make, and VIN, the latter of which can be used to identify a particular vehicle.

Creating a new contract returns its newly assigned address. In the function, using the mapping of the vehicle, we bind the given VIN to the address. Finally, the function broadcasts a new event, passing in the address and the current timestamp.

Code Example 2

contract BasicIterator
{
address creator; // reserve one "address"-type spot
uint8[10] integers; // reserve a chunk of storage for 10 8-bit unsigned integers in an array

function BasicIterator()
{
creator = msg.sender;
uint8 x = 0;
//Section 1: Assigning values
while(x < integers.length) { integers[x] = x; x++; }}function getSum() constant returns (uint) {
uint8 sum = 0;
uint8 x = 0;
//Section 2: Adding the integers in an array.

while(x < integers.length) {
sum = sum + integers[x];
x++;
}

return sum;
}

// Section 3: Killing the contract
function kill()
{
if(msg.sender == creator) { suicide(creator); }}}Copy the code

So, let’s break it down.

Section 1: Assignment

In the first step, we assign an array named “integers” that accepts 10 8-bit unsigned integers. And the way we do that is through a while loop. Let’s look at what happens in the while loop.

while(x < integers.length) {
integers[x] = x;
x++;
}
Copy the code

Remember that we have assigned “0” to the integer x. The while loop changes from 0 to integers. Length. Integers. Length is a function that returns the maximum size of an array. So, if we determine that an array will have 10 integers, arrayName.length will return a value of 10. In the loop above, the same is true for x, which takes the value from 0 to 9 (<10) and assigns its own value to the integer array. Thus, at the end of the loop, “integers” will have the following values:

0,1,2,3,4,5,6,7,8,9.Copy the code

Section 2: Adding the contents of an array

Inside the getSum() function, we’ll add the contents of the array itself. It does this by repeating the same while loop above and using the variable “sum” to add the contents of the array.

Section 3: Termination of Contract

This function terminates the contract and sends the remaining funds in the contract back to the contract creator.

So this should give you a better idea of what the Solidity contract looks like and what type of code breakdown you should get from there.

What’s the difference between ether and gas?

This is another core concept that your developers should be familiar with.

Aether is the primary marker in the ecosystem. This is what motivates players to complete smart contracts.

Gas is the amount of fuel required to meet a particular contract.

When someone submits a smart contract, it has a predetermined gas value. When the contract is executed, a certain amount of gas is required for each step of the contract.

This can lead to two things:

  • Required gas exceeds the set limit. If this is the case, the contract state reverts to its original state and all the gas is used up.
  • The gas required is less than the set limit. If this is the case, then the contract is complete and the remaining gas goes to the contractor.

Below is a chart showing Wei’s average gas prices.

Gas is the lifeblood of Ethereum.

All transactions in Ethereum are verified by miners. Basically, they have to manually place each transaction into the block they mine to validate the transaction. In exchange for their services, they charge a transaction fee.

Typically, smart contracts with high gas rates are preferred because miners have the opportunity to charge higher rates there. The fees charged are nominal compared to bitcoin.

This chart compares transaction fees for Bitcoin to Ethereum.

In fact, as you can see, in this transaction of 0.01 ether, only gas of 0.00000000000002 ether is charged as transaction fee <$0.000001.

So, as you can see, ethereum miners charge very token transaction fees. Obviously collecting transaction fees is a secondary role for miners, whose main job is…… Okay… Dig!

Questions and Solutions

Distill all this knowledge and let’s ask some specific questions you can ask.

1. Question: How is the contract constructor defined? Answer: The constructor is defined as a function with the same name as the contract.

2. Question: Where are the events recorded in Ethereum? What is their purpose? Answer: A log is an event issued by a contract. These are part of its transaction receipt and the result of LOG Opcodes executed on the Ethereum VIRTUAL machine (EVM). These events are mainly used to communicate with the front end or as cheap data storage. Because the return value of the transaction is just the hash of the transaction, the blockchain takes some time to reach consensus and validate the transaction by mining them into new blocks. Efficient communication is achieved by issuing events and having the front end listen to (observe) these events.

3. Q: What is a mappings? Answer: Mapping is equivalent to dictionaries or mappings in other programming languages. It’s a key-value store.

4. Q: What is the purpose of the purpose of modifiers? Answer: As the name implies, they modify the functions that use them. However, the conditions of the qualifier must be satisfied before the function can be executed. If not, the modifier throws an error.

5. Question: What are Ethereum libraries? Answer: Ethereum libraries help isolate the overall logic. They are a set of software packages used on the blockchain using the Ethereum Virtual Machine (EVM). All libraries can be deployed and linked in smart contracts. They can be called by DELEGATECALL.

6. Question: Why does calling a method on a smart contract cost money? Answer: When methods are called, they change the state of the blockchain. Because the operation requires gas, it costs money.

Where can I find good developers?

It’s hard to find good developers in “traditional places” like LinkedIn and Google. However, Reddit, GitHub, etc are good places to find these developers.

And there’s one more thing. Since this is a niche talent market, you should be open to the fact that they might be in your city or even your own country. Be prepared to work remotely, especially if you’re looking for a good developer.

It may be a pain, but it’s one of those “quality over quantity” situations that must be faced.

conclusion

There’s one thing you have to keep in mind when interviewing Ethereum developers. They don’t have to answer all the questions thoroughly. What matters is their enthusiasm and whether they can specifically answer questions related to their job and role.

In any case, this guide should help you get to know the particular blockchain developer. A final word of advice: don’t compromise developer quality. Remember, quality always trumps quantity.

= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

Share some interactive online programming tutorials related to blockchain such as Ethereum, EOS and Bitcoin:

  • Java Ethereum development tutorial, mainly for Java and Android programmers for blockchain Ethereum development web3J details.
  • PHP Ethereum, mainly introduces the use of PHP for smart contract development interaction, account creation, transactions, transfers, token development, filters and transactions and other content.
  • Ethereum introductory course, mainly introduces smart contract and DAPP application development, suitable for entry.
  • Ethereum development advanced tutorial, mainly introduces the use of Node.js, mongodb, blockchain, IPFS to achieve decentralized e-commerce DApp combat, suitable for advanced.
  • Python Ethereum is a detailed explanation of blockchain ethereum development by Python engineers using Web3.py.
  • C# ethereum, mainly explains how to use C# based development. Net ethereum applications, including account management, status and transactions, smart contract development and interaction, filters and transactions, etc.
  • This course will help you get a quick start on the development of EOS blockchain decentralized applications. It covers core knowledge points such as EOS tool chain, account and wallet, issuing tokens, development and deployment of smart contracts, and interaction between codes and smart contracts. Finally, the development of a notepad DApp will be completed using all knowledge points comprehensively.
  • Java development tutorial COINS, this course for beginners, content covers the core concepts of COINS, such as block mechanism, key chain store, decentralized consensus and script, trading and UTXO etc, also explained how to integrate the currency support functions in Java code, such as creating address wallet, tectonic naked trading, management, Is a rare bitcoin development course for Java engineers.
  • PHP currency development tutorial, this course for beginners, content covers the core concepts of COINS, such as block mechanism, key chain store, decentralized consensus and script, trading and UTXO etc, also explained how to integrated the currency support functions in PHP code, such as creating address wallet, tectonic naked trading, management, This is a rare bitcoin development course for Php engineers.

Huizhi net original translation, reprint please indicate the source. Here is the original text