1

How To Hire Ethereum Developers (Ultimate Guide)

There is a huge demand for quality Ethereum developers and to hire Ethereum developers, and for good reason. The blockchain and ICO space have exploded over the last couple of years. More and more people are trying to get in and make their name in the space. However, in order to be successful, it is critical for them to have a strong and sound team. Blockchain developers, and to be more precise, Ethereum developers are the most critical component of that team.

Hire Ethereum Developers

So, in this guide, we are going to make your life a lot easier. We are going to show you how you can pinpoint and shortlist the cream of the crop.

Before we hire an ethereum developer though, it is important that we know what kind of people we are hiring.

What Makes a Great Ethereum developer?

In a skill which is as niched as “Ethereum Developer”, it is important to know what are the base qualities that separates the best from the rest? A great developer must be more than just a coder with blockchain coding skills. We are not saying that simple coders aren’t valuable, however, you need a proper developer in order to create an empire. So, what are some of the main qualities that you are looking for?

  • Strong Faith in Decentralization: These people believe that decentralization will salvage humanity. These are the kind of people who traditional corporations won’t hire because of their belief that institutions like societies, corporations, and governments should get decentralized.

 

  • Mastery of Cryptography: Blockchain developers need to have mastery in crypto economics. There are two parts to crypto-economics, cryptography, and economics. This is why a great Ethereum Developer should have an undying curiosity for cryptography.

 

  • Mastery of Economics: The second half of crypto economics is “Economics” so an expert developer should have sound knowledge of economy and game theory mechanics as well. If you are creating a blockchain platform, the code should make sure that all the participants are economically incentivized.

 

  • Extreme Curiosity: In order to have such a humongous knowledge base, these people are extremely curious by nature. These are the kind of people who are up till late at night going through videos, forums, wikis to understand a particular problem.

So, now we know the kind of people that we are looking for. This is why it makes sense to start from the scratch with some Ethereum basics.

Why are we doing that?

Because every Ethereum developer worth their salt should be completely well-versed in these concepts.

What is Ethereum?

This is how Ethereum’s website defines itself:

“Ethereum is a decentralized platform that runs smart contracts: applications that run exactly as programmed without any possibility of downtime, censorship, fraud or third party interference. These apps run on a custom built blockchain, an enormously powerful shared global infrastructure that can move value around and represent the ownership of property.”

But in simpler terms, Ethereum is planning to be the ultimate software platform of the future. If the future is decentralized and dAPPs become commonplace, then Ethereum has to be the front and center of it.

While Bitcoin is the first application of the blockchain technology, it is still only a currency. Ethereum brings with it the whole scope of what could be possible in a blockchain technology.

As Ethereum co-founder Dr. Gavin Wood puts it:

“Bitcoin is first and foremost a currency; this is one particular application of a blockchain. However, it is far from the only application. To take a past example of a similar situation, e-mail is one particular use of the internet, and for sure helped popularise it, but there are many others.”

How Does Ethereum Mining Work?

As of right now, Ethereum is using the same Proof-of-Work protocol that Bitcoin is using.  However, Ethereum soon plans to move over to Proof-of-stake and they are going to use the Casper protocol to make this transition.

So what is the difference between proof of stake and proof of work? This is actually something that you can ask people that you are potentially interviewing. Knowing how proof-of-work and proof-of-stake works are absolutely critical.

Proof of work: This is the protocol that most cryptocurrencies like Ethereum and Bitcoin have been following so far. This means that miners “mine” cryptocurrencies by solving crypto-puzzles using dedicated hardware.

Proof of stake: This protocol 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 will first have to lock up some of your ether as stake. After doing that you will then start validating blocks which basically means that if you see any blocks that you think can be appended to the blockchain, you can validate it by placing a bet on it. When and if the block gets appended, you will get a reward proportional to the stake you have invested. If, however, you bet on the wrong or the malicious block, the stake that you have invested will be taken away from you.

To implement “proof of stake” Ethereum is going to use the Casper consensus algorithm. In the beginning, it is going to be a hybrid style system where the majority of the transactions will still be done a proof of work style while every 100th transaction is going to be proof of stake. What this will do is that it will provide a real-world test for proof of stake on Ethereum’s platform. But what does that mean for Ethereum and what are the advantages of this protocol? Let’s take a look.

How To hire The Perfect Ethereum Developer

Advantages of proof of stake

  • Lowers the overall energy and monetary cost: The world’s bitcoin miners spend around $50,000 per hour on electricity. That’s $1.2 million per day, $36 million per month and ~$450 million per year! Just put your head around those numbers and the amount of power being wasted. By using “Proof-of-stake” you are the making the whole process completely virtual and cutting off all these costs.

 

  • No ASIC advantage: Since the whole process will be virtual, it wouldn’t depend on who has the better equipment or ASICs (application-specific integrated circuit).

 

  • Makes 51% attack harder: 51% attack happens when a group of miners gains more than 50% of the world’s hashing power. Using proof of stake negates this attack.

 

  • Malicious-free validators: Any validator who has their funds locked up in the blockchain would make sure that they are not adding any wrong or malicious blocks to the chain because that would mean their entire stake invested would be taken away from them.

 

  • Block creation: Makes the creation of newer blocks and the entire process faster.

 

  • Scalability: Makes the blockchain scalable by introducing the concept of “sharding” (More on this later.)

Even though there have been various simplistic implementations of Proof of Stake before, what separates Casper from the rest is that it incentivizes the honest miners and punishes the dishonest ones. If you have put your stake on a malicious block, then the stake will be taken away from you. It will punish anyone who doesn’t play by the rules.

This is how Vitalik explains it:

“Imagine 100 people sitting around a circular table. One person has a bundle of papers, each with a different transaction history. The first participant picks up a pen and signs one, then passes it onto the next person, who makes a similar choice. Each participant only gets $1 if they sign the transaction history that most of the participants sign in the end. If you sign one page and later sign a different page, your house burns down,”

He then added that this is probably a good incentive to sign the right piece of paper!

What are Smart Contracts?

Smart contracts are automated contracts. They are self-executing with specific instructions written on its code which get executed when certain conditions are made.

How To hire The Perfect Ethereum Developer

You can learn more about smart contracts in our in-depth guide here.

Smart contracts are how things get done in the Ethereum ecosystem. When someone wants to get a particular task done in Ethereum they initiate a smart contract with one or more people.

Smart contracts are a series of instructions, written using the programming language “solidity”, which works on the basis of the IFTTT logic aka the IF-THIS-THEN-THAT logic. Basically, if the first set of instructions are done then execute the next function and after that the next and keep on repeating until you reach the end of the contract.

The best way to understand that is by imagining a vending machine. Each and every step that you take acts like a trigger for the next step to execute itself. It is kinda like the domino effect. So, let’s examine the steps that you will take while interacting with the vending machine:

Step 1: You give the vending machine some money.

Step 2: You punch in the button corresponding to the item that you want.

Step 3: The item comes out and you collect it.

Now look at all those steps and think about it. Will any of the steps work if the previous one wasn’t executed? Each and every one of those steps is directly related to the previous step. There is one more factor to think about, and it is an integral part of smart contracts. You see, in your entire interaction with the vending machine, you (the requestor) were solely working with the machine (the provider). There were absolutely no third parties involved.

So, now how would this transaction have looked like if it happened in the Ethereum network?

Suppose you just bought something from a vending machine in the Ethereum network, how will the steps look like then?

Step 1: You give the vending machine some money and this gets recorded by all the nodes in the Ethereum network and the transaction gets updated in the ledger.

Step 2: You punch in the button corresponding to the item that you want and record of that gets updated in the Ethereum network and ledger.

Step 3: The item comes out and you collect it and this gets recorded by all the nodes and the ledger.

Every transaction that you go through the smart contracts will get recorded and updated by the network. What this does is that it keeps everyone involved with the contract accountable for their actions. It takes away human malice by making every action taken visible to the entire network

Ok so till now we have covered what Ethereum is, what is mining, and what are smart contracts. If your candidate can’t answer any of these satisfactorily then let them go at that very instant. It is not worth your time.

Mastery of Smart Contract Code

Obviously, this should be the bread and butter of all great developers. One way that you can definitely understand the expertise of a developer is by asking them to explain how a particular contract works. Here we are going to show you two solidity codes. You can run this code by them and ask them to break it down and explain to you what is happening in each and every step.

Code Example #1

The code and explanation has been taken 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);
        _;
    }

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

So, let’s go line and by line and understand what is happening here.

 

Code: pragma solidity 0.4.18;

 

Analysis: Specifies the version of the compiler used. In this 0.4.18

 

Code: import “./Vehicle.sol”;

 

Analysis: Imports the smart contract which is used to represent new vehicles.

 

Code: contract VehicleOwner {

 

Analysis: Declares the vehicle owner contract.

 

Code:

address public owner;

mapping(bytes32 => address) public vehicles;

 

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

The second one, called vehicles, will be used to store a list of the vehicles owned by the owner, by assigning their contracts’ addresses to the provided vehicle identification numbers.

 

Code:

function VehicleOwner() public {

owner = msg.sender;

}

 

Analysis: See how the function has the same name as the contract? This is because this particular function is a constructor. The only function that it does is to assign the address that called the function as the contract owner.

 

Code:

modifier onlyOwner() {

require(msg.sender == owner);

_;

}

 

Analysis:  This function modifier is used make sure that only the contract owner has access to the contract.

 

See that “_”?

 

This yields for the body of the function to which the modifier is later applied.

 

Code:

function createNewVehicle(string model, string make, bytes32 vin) public onlyOwner {

address newVehicle = new Vehicle(model, make, vin);

vehicles[vin] = newVehicle;

NewVehicleAdded(newVehicle, now);

}

 

Analysis: This creates a new contract on the blockchain which is a representation of a new vehicle. The vehicle contract’s constructor receives three properties: model, make, and vin, the latter of which can be used to identify that particular vehicle.

Creating a new contract returns its newly assigned address. In the function, using the vehicle’s mapping, we bind the given vin to that 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);



}



}



}


So, lets analyse.



Section 1: Assigning Values



In the first step we are filling up an array called integers which takes in 10 8-bit unsigned integers.  The way we are doing it is via a while loop. Lets look at what is happening inside the while loop.



while(x < integers.length) {



integers[x] = x;



x++;



}

Remember, we have already assigned a value of “0” to the integer x. The while loop goes from 0 to integers.length. Integers.length is a function which returns the max capacity of the array. So, if we decided that an array will have 10 integers, arrayname.length will return a value of 10. In the loop above, the value of x goes from 0 – 9 (<10) and assigns the value of itself to the integers array as well. So, at the end of the loop, integers will have the following value:

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

Section 2: Adding the array content

Inside the getSum() function we are going to add up the contents of the array itself. The way its going to do it is by repeating the same while loop as above and using the variable “sum” to add the contents of the array.

Section 3: Killing the contract

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

So this should give you a good idea of what solidity contracts look like and what kind of code breakdown you should expect from your prospects.

What’s the difference between Ether and Gas?

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

Ether is the main token in the ecosystem. It is what incentivizes the players to carry out their end of the smart contract.

Gas is the amount of fuel that is required to fulfill all the needs of a given contract.

When someone submits a smart contract, it has a pre-determined gas value. When the contract is executed each and every step of the contract requires a certain amount of gas to execute.

This can lead to two scenarios:

  • The gas required is more than the limit set. If that’s the case then the state of the contract is reverted back to its original state and all the gas is used up.
  • The gas required is less than the limit set. If that’s the case, then the contract is completed and the leftover gas is given over to the contract setter.

The following is a graph that shows the average gas price in Wei.

How To hire The Perfect Ethereum Developer

Image Credit: Etherscan

Gas is the lifeblood of Ethereum.

All the transactions in Ethereum are validated by the miners. Basically, they have to manually put each and every transaction into the blocks that they have mined for the transaction to be validated. In exchange for their services, they collect a certain amount of transaction fees.

Usually, smart contracts with high gas fees are given preference because the miners have the chance to collect higher fees there. The fee collected though is still pretty nominal as compared to bitcoin.

This graph here compares the transaction fees of Bitcoin to Ethereum.

How To hire The Perfect Ethereum Developer

Image Credit: Bitinfocharts

In fact, as you can see, in this transaction of 0.01 Ether only 0.00000000000002 Ether was collected as transaction fees which is <$0.000001.

How To hire The Perfect Ethereum Developer

Image Credit: Etherscan

So, as you can see, the miners in Ethereum, writing, collect very nominal transaction fees. Obviously collect transaction fees is a secondary role for there miners, their main job is to…well…mine!

Questions and Answers

So, distilling all this knowledge, let’s zero in on some specific questions that you can ask.

  1. Q) How is the contract constructor defined?
  2. A) The constructor is defined as a function, named exactly the same as the contract.

 

  1. Q) Where are events logged in Ethereum and what’s their purpose?
  2. A)  Logs are the events emitted by the contracts. These are parts of their transactions’ receipts and the results of the LOG opcodes which is executed on the Ethereum Virtual Machine (EVM).

The events are primarily used to communicate with front ends or as cheap data storage. Because the return values of transactions are only the transactions hashed, because it takes a bit of time for the blockchain to reach consensus and validate the transactions, by mining them into new blocks. By emitting events and having front ends listen (watch) for those events, efficient communication is achieved.

  1. Q) What are the mappings?
  2. A) Mapping is equivalent to a dictionary or a map in other programming languages. It’s key-to-value storage.

 

  1. Q) What is the purpose of modifiers?
  2. A) As the name suggests; they modify the functions that use them. However, the conditions of the modifier must be met before the function gets executed. If not, then the modifiers throws an error.

 

  1. Q) What are Ethereum libraries?
  2. A) Ethereum libraries help in the isolation of integral pieces of logic. They are a group of packages built for use on blockchains utilizing the Ethereum Virtual Machine (EVM). All libraries are deployed and linkable in your smart contracts. They can be called via DELEGATECALL.

 

  1. Q) Why does it cost money to invoke a method on a Smart Contract?
  2. A) When methods get invoked, they change the state of the blockchain. Since the operation requires gas, it costs money.

 

Where can you find great developers?

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

Plus, there is one more thing. Since this is such a niche talent, you should be open to the fact that they might be in your city or even your own country. You should make provisions for remote location jobs, especially if you are looking for the cream of the crop.

It may be a pain, but this is one of those “quality over quantity” things.

How To Hire Ethereum Developers: Conclusion

When you are interviewing Ethereum developers, you must keep one thing in mind. It is not necessary that they answer all the questions thoroughly. What matters is their passion and whether they were able to specifically answer the questions which pertain to their job and role.

Anyway, this guide should help you zero in on amazing blockchain developers. Just one final word of advice. Please do not compromise on the quality of the developers. Remember, quality will always trump quantity.

Like what you read? Give us one like or share it to your friends

17
1

Related Guides

Join Blockgeeks

Create an account to access our exclusive point system, get instant notifications for new courses, workshops, free webinars and start interacting with our enthusiastic blockchain community. Don’t miss out and join right now!

Already have an account? Sign In

Comments