Hire the Top 3% of Freelance Ethereum Developers

The new paradigm of Ethereum development brings with it many moving parts. Smart contracts, distributed applications (or “dapps”, sometimes stylized “ĐApps”), the “ether” cryptocurrency, a world-wide virtual machine where work is measured in “gas”—all of this is in addition to the basic underlying blockchain technology.

Navigating this isn’t anywhere close to being second nature for most people, even from a user standpoint. That said, how can a non-expert make a reasonable assessment of a potential Ethereum developer candidate?

Before we discuss ĐApp development, let’s first get acquainted with some basic Ethereum background. After that, we’ll jump into the questions and answers one might expect in an interview for an Ethereum-related position.

Who’s Driving Ethereum?

Vitalik Buterin invented Ethereum in 2013, and in 2014, it had ICO backing, going live in 2015. Ethereum development is a cutting-edge and exciting frontier. At the time of writing, there aren’t very many full-time blockchain engineers, and even fewer have hands-on experience developing Ethereum solutions.

Interactions between Ethereum experts are what drive the technology.

So early in the history of Ethereum, it may seem unreasonable to expect to be able to hire actual experts with years of experience, those who may have run meetup groups or development services, helped startups as advisors, or completed an ICO.

That being the case, it’s important that contemporary Ethereum developers are committed to becoming true experts. It’s best that they’re connected to current Ethereum experts in meaningful ways. The engineer who knows people in their local blockchain community, or attends meetups or conferences, or who has a good reputation in online Ethereum communities, will likely have a suitable passion for the subject and level of outside support to effectively develop Ethereum blockchain technology for your project. The best blockchain engineers will have communication skills to go along with their technical skills.

Key Ethereum Concepts

With technology so new and unfamiliar, there’s a tendency to try to use it as a solution to the wrong set of problems. It may be wise to consult an experienced Ethereum developer before deciding whether to hire an entire development team. After all, Ethereum programmer jobs are more plentiful than Ethereum programmers at the moment.

But with a few key concepts in mind, you’ll find it a lot easier to have a sensible conversation about where and how Ethereum can be used in your project—and where it might ultimately be a bad fit.

The Ethereum Blockchain

Just like Bitcoin and many other cryptocurrencies, the Ethereum project is an implementation of blockchain technology.

A blockchain is a distributed database. It consists of sets of data, called blocks, with each block containing a reference to the previous one, in addition to its actual data payload and timestamp. The references to the previous blocks are what link the blocks together, forming the chain. The true components of the blocks vary between implementations; for example, Ethereum’s blocks don’t follow the exact same format as Bitcoin’s.

Blockchains are unchangeable by design. With every new block linking to the permanent state of the previous block, its history can be traced all the way back to the first block. In addition, the balance of every account is publicly visible.

Adding transactions means there will temporarily be differing copies of the blockchain within the network. The effect of synchronizing these copies is that, in the end, the longest chain emerges, and consensus is reached. Based on these attributes and the democratic mechanisms to achieve consensus, blockchains can guarantee the integrity of their assets. This integrity is beneficial to applications in many industries. Non-fungible tokens (NFTs) are an example of a blockchain application that goes beyond finance. In addition, industries that rely heavily on contracts, such as real estate, collectibles, or e-commerce, can all benefit from blockchain technology.

It’s not really necessary for all Ethereum developers to have a thorough understanding of the contents of every block nor the cryptography underlying the ether cryptocurrency. But when you’re looking to implement new protocols or create tools for other developers, it will be highly beneficial to hire Ethereum developers who have a background in cryptography and/or strong familiarity with the underlying distributed ledger technology.

In the end, if you’re looking for decentralized solutions to applications that are currently centralized, you should know as much about the technology and suitable alternatives as possible. You’ll want to hire an Ethereum developer who can explain to you, with clarity, even the most complex aspects of the Ethereum architecture and ecosystem.

Proof of Consensus?

Since every real node on the blockchain network has a copy of the blockchain, and new transaction blocks need to be synchronized among nodes, a few problems arise:

• How to prevent attackers from flooding the network with invalid blocks
• How to maintain an integral transaction history such that the nodes in the network will treat it as the source of truth
• How to minimize the risk of double-spending

Any Ethereum developer worth hiring will be able to comment on the above issues and how they are approached in the Ethereum model. But that’s not the only issue. Ethereum currently uses a proof-of-work algorithm called Dagger-Hashimoto to achieve consensus. But why is that a problem?

It turns out that there’s a major flaw related to proof-of-work algorithms in blockchain technology: They are very costly and have a strong impact on the environment. As of February 2018, Ethereum power consumption was closing in on that of the Dominican Republic and outweighed that of around 150 other countries.

Even though the numbers seem massive, it is less than half of what Bitcoin uses. To be precise, Ethereum uses 34% of Bitcoin’s current yearly energy consumption, which currently is 51 TWh. Those numbers are already comparable; meanwhile, side-effects like this are already a reality:

Data available on a coal-powered bitcoin mine in Mongolia indicates the mine is responsible for 8,000 to 13,000 kg of carbon dioxide emissions per bitcoin, and 24,000 to 40,000 kg per hour. Tweeter Matthias Bartosik noted similar estimates: the average European car emits 0.1191 kg of carbon dioxide per kilometer driven. For every hour, the bitcoin mine emits at least the carbon dioxide equivalent of more than 203,000 car kilometers traveled.
Lester Coleman, Bitcoin Price Surge Leads to Electricity Consumption Spike: Blog Questions Environmental Impact, November 2017

The massive energy use of blockchains using proof-of-work to reach consensus was one of the motivators for the plan to move Ethereum towards another algorithm: proof-of-stake. While that resolution would be bright for the world’s ecology, the algorithm planned for the official release of Ethereum v1.0, called Ethash, is still an extension of its original proof-of-work algorithm. Proof-of-stake, on the other hand, is planned for Ethereum v1.1.

In the proof-of-stake method of achieving consensus, the next node to mine a block is chosen based on randomness and the size of a miner’s stake. In effect, the next miner could be any node in the system, but the ones holding more coins are more likely to win.

There are some modifications to that basic algorithm, like weighing in the age of the coin. However, it has been criticized as being less safe for the integrity of the network because the nodes have less motivation to act honestly.

To answer this, Buterin suggested a punitive version of the proof-of-stake algorithm called Slasher. If implemented, any dishonest nodes would actually lose coins.

Ethereum Questions and Answers

Keep in mind that hiring is both an art and a science. A developer does not need to answer every question perfectly. What’s important is to what degree a question applies to the specific job or project.

For this hiring guide, we will provide a short example of a smart contract, outlining some common structures used in Ethereum applications. The example is based on a sketch used in the Blockchain-IoT open-source project.

The referenced smart contract is written in Solidity, the most popular language for smart contracts. It compiles to Ethereum Virtual Machine (EVM) bytecode. To compile the contract, you need a compiler like Solc-js—see the end of this article for other such tools and resources.

For the following contract, explain what each line of Solidity code does:

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);
    }
}

Let’s walk through the code, line by line.

pragma solidity 0.4.18;

This line only specifies the version of the compiler, in this case, 0.4.18.

import "./Vehicle.sol";

With this line, we import a smart contract that represents new vehicles.

contract VehicleOwner {

This line opens the VehicleOwner contract definition, which is closed on the last line.

    address public owner;
    mapping(bytes32 => address) public vehicles;

Here, we define public variables, or the properties of the contract. The first one, called owner, represents the Ethereum address 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 (VINs).

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

Note the particular naming of this function. This is the contract constructor, named exactly like the contract, written in upper camel case, or Pascal case—i.e., each compound word starts with an uppercase letter. The only thing that this constructor does is assign the address that called the function—i.e. the person who is creating the contract—as the contract owner.

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

This function modifier is used to limit access to only the owner of the contract. The underscore yields to the body of the function, to which the modifier is later applied. If the require condition passes, the function call is executed.

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

This public function of the contract, with access limited to the contract owner’s address by the modifier, creates a new contract on the blockchain—a representation of a 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 vehicles mapping, we bind the given vin to that address. Finally, the function broadcasts a new event, passing in the address and the current timestamp.

Now that you have an overview of the above script, you’re in a better position to ask the following questions about programming in Solidity:

How is the contract constructor defined?

The constructor is defined as a function and named the same as the contract.

Where are events logged in Ethereum?

The events emitted by contracts are the logs. These terms are used interchangeably based on the context. They are parts of their transactions’ receipts and the results of ‘LOG’ opcodes executed on the EVM. For optimization reasons, they are logged alongside the blockchain but not stored in the blockchain itself.

What is the purpose of using events?

Events can be used as a means to communicate with front ends or as cheap storage for data. Basically, the return values of transactions are only the transactions hashed, because it takes a bit of time for the blockchain to mine the transactions into new blocks and validate them. By emitting events and having front ends listen (watch) for those events, efficient communication is achieved.

What is the purpose of modifiers?

Modifiers are similar to decorators: They modify the body of the functions that use them, in such a way that the conditions of the modifier must be met before the original function body is executed. If they are not met, the modifier throws an error.

What are mappings?

Mappings are data types in Ethereum that are similar to hash tables. However, mappings are not exactly the same as hash tables; their values are not stored inside them. Storing data in objects requires defining a struct type (schema, interface). Storage processes are some of the most expensive operations in terms of transaction costs.

Why are smaller smart contracts preferred?

Reasons for compact code structures are common in software engineering. Simple, well-structured code with low cyclomatic complexity is easier to understand, reuse, test, and maintain.

Creating large, monolithic contracts is not the best idea because there are gas limits for blocks and transactions. Blocks can only store a limited amount of data, and that limit may block your contract from being migrated to the blockchain.

Creating contracts on Ethereum comprises making a transaction to an empty address with the contract’s EVM code as data. With every transaction, the sender specifies the amount of gas allocated and the gas unit price. When deploying a smart contract, every code structure has a gas cost.

The client software used to make the transaction and deploy the contract should be able to prevent migrating any contract that exceeds the limits. It is not easy, however, to predict the exact final cost associated with a transaction. If the supplied gas amount is insufficient to cover the fees, the computations are stopped, and the used gas is not returned.

(The Ethereum yellow paper has a list of fees for your reference.)

How would you update a smart contract?

This question is particularly tricky. Any updates to a contract result in a new smart contract with a new address, and the old address and contract persist. Until now, there is no single best practice for dealing with this. However, there are many approaches.

One rather elegant solution was described by Aigang. They issued a contract register that stored all the addresses of their contracts but returned only the latest one. Then before making any calls to their contracts, they would obtain the most recent address from the registry.

There was another problem, though: The data is stored with the contract. The solution was to keep the data in a separate contract. Obviously, this approach has limitations, but it seems manageable, especially during the early stages of application development.

However, there’s a simpler approach: using new contracts. With this solution, the problem of data storage still exists, and so the final approach should be suited to the actual needs of one’s project.

Explain Ethereum libraries.

Libraries are used to separate concerns in smart contracts. In particular, they isolate integral pieces of logic. Libraries are not instantiated and they cannot store data. Their code is called using ‘DELEGATECALL’ in the context of the calling contract.

It is as if the code in the library were a part of the smart contract that’s calling it. The main difference is that it is not actually part of it, and it can be reused by other contracts. Using libraries also makes transactions more cost-effective by reducing contract complexity and gas costs.

How do Ethereum smart contracts communicate with the outside world?

Smart contracts cannot communicate with the outside world, by definition, because all of the nodes need to be able to access all the processed data (or derived values) to validate the integrity of the blockchain. The data in the outside world is not immutable and certainly not predictable in this manner.

The workaround to that limitation is delivered by oracles. An oracle is a piece of software—sometimes embedded—that listens for specific blockchain events and responds by sending data from the outside world to smart contracts on the blockchain.

The problem remains that in order for the blockchain to validate such a transaction, trust must be placed in the oracle. A more elegant solution is much like the blockchain itself: Single oracles aren’t trusted, but a swarm of oracles facilitates consensus on the processed data. Chainlink Labs is an example of a company that provides oracle services.

What is integer division, and why is it important for smart contract development?

Integer division is the arithmetic operation in which the integer quotient is obtained from two operands. The fractions of the result are discarded, and the result itself is truncated towards zero, or rounded down to the nearest integer, compared to the result of floating point division. For example:

10 / 3 = 3

Consider its application to a real-world scenario:

uint totalShares = 99;
uint stakeholders = 5;
uint sharesPerStakeholder = totalShares / stakeholders; // 19
uint totalSharesLeveled = sharesPerStakeholder * stakeholders; // 95
uint remainder = totalShares - totalSharesLeveled; // 4

Arithmetic operations in Solidity are done on the lowest denomination of ether, called wei.

1 ether = 1 wei * 10**18 // or 1e18 wei

Since, by convention, we tend to trade in the ether cryptocurrency, the situation is the equivalent of ether having 18 decimal points. That number 18 may be turning into a decimal standard for Ethereum tokens. Most clients look for the public variable ‘decimals’ to represent the held integer value in ether. While not obligatory, ERC20 tokens often implement it:

uint8 public constant decimals = 18;

What are wei, szabo, finney?

These are ether denominations named after the cypherpunks, researchers, and developers of cryptocurrencies. wei, the lowest denomination of ether, is also called the base unit of ether. In fact, ether is expressed as 1e18 (one quintillion) wei, or 1,000,000,000,000,000,000 wei.

Szabo and finney are similar, but higher, denominations: 1e12 (one trillion) and 1e15 (one quadrillion) wei, respectively. Note that there are also other denominations, named similarly. One shannon is 1e9 (one billion) wei; you may also see it referred to as Gwei (giga-wei).

The particular trivia behind the main three denominations:

• Wei Dai is the inventor of b-money, which was one of the inspirations for Bitcoin.
• Hal Finney is the first Bitcoin user (apart from Satoshi Nakamoto, the creator of Bitcoin) and the first recipient of a transaction.
• Nick Szabo is a smart contracts researcher.

What is the relationship between ether and gas?

Gas is the cost of Ethereum resource utilization (the cost of executing transactions on the EVM). Simple transfers will cost less than migrating a smart contract to the blockchain, but these transactions both have their processing cost expressed in units of gas.

The price of executing transactions on the Ethereum network is meant to stay constant over time. The price for a gas unit is not bound to the value of ether, but it is expressed in ether. In other words, the cost of transactions should not rise together with ether.

When sending out a transaction, in addition to the value in ether, the sender specifies the maximum amount of gas to use for the transaction, as well as the gas price. The final cost is calculated by the simple formula transaction cost = gas × gas price. Transaction fees are paid out in ether to miners.

What’s Your Ethereum Stack?

We’re almost at the end of this guide about hiring Ethereum developers. Hopefully, we’ve provided a better understanding of the mechanics of Ethereum’s blockchain and what’s involved in building a blockchain solution. Most importantly, you should have a better awareness of the distinction between designing software for traditional, centralized systems versus decentralized blockchains.

Consider how Bitcoin and Ethereum were designed to allow for direct, trustless transactions between the networks’ participants. Due to leveraging proof-of-work, among other algorithms, for reaching consensus, the platforms strive to avoid reliance upon trusted third parties.

This has strong implications for the design of apps that are meant to be published on the blockchain. When considering Ethereum application architecture, keep in mind that blockchain takes over many of the responsibilities of traditional, centralized servers, but it also brings changes. If the services or products you plan to offer via blockchain are somehow bound to your company, then you are still making centralized apps.

This presents two challenges. The first is to develop a plan that will allow users to benefit from the smart contracts you provide without having to refer to your company. A smart contract should allow two parties to make some type of transaction involving cryptocurrency, stocks, bartering, etc. The second challenge is finding the business application for your blockchain-based product. Success stories include DeFi exchanges such as Uniswap and Loopring. These services stand in contrast to typical exchanges, which deal with cryptocurrency but in reality, are centralized platforms with the trading happening off-chain.

On the other hand, it wouldn’t make sense for some businesses to keep everything on a blockchain. In particular, sensitive data should be stored securely and kept secret—in many cases, this is a legal requirement.

It is also very important to note that every transaction on Ethereum is rather expensive and slow. Even when transactions become validated, waiting for a few more blocks to be mined is a good idea. The reason is that very recent blocks can potentially become identified as not part of the canonical blockchain, and already-mined transactions then get reverted. That process is called chain reorganization, and it happens quite often.

Also, the code on a blockchain cannot communicate with external services. For those reasons, keeping all business operations on a blockchain may be too much for most businesses. While it’s crucial for smart contracts to be independent and built with openness in mind, there’s nothing wrong with making your SaaS and Ethereum ĐApps the very best interface for the contracts in question, as long as other interfaces can be built without having to rely on your business.

Be Smart About Smart Contract Developers

Smart contracts, including the one given as an example, are public on the blockchain. Business motivations drive the creation of new software, but the right Ethereum engineer will design smart contracts so that they are in line with the public, transparent nature of blockchains, lest they fail when trying to transition centralized logic to a blockchain. There are also limitations of smart contracts that need to be taken into account. In some cases, it’s still rather early for full blockchain adoption because more changes are underway.

In the end, you’ll want to hire top Ethereum blockchain developers who also have as good a mind for business as they do for programming. The world of Ethereum app development is a wild one—all the more reason to hire the most dependable and skilled Ethereum developers you can find.

Further Ethereum Resources to Explore

We recommend the following high-quality public resources to study various Ethereum-related subjects in detail and experiment with different tools:

Popular Ethereum Clients

• Geth, aka Go Ethereum
• Parity, the Rust implementation

Popular Frameworks for Developing Smart Contracts and ĐApps

• Embark, another popular JavaScript framework, with integrations beyond Ethereum EVM
• Exonum, a framework in Rust
• Populus, a smart contract development framework for Python
• Open Zeppelin library, a collection of secure, tested, and community-audited smart contracts for use as building blocks, integrated with the Truffle framework

Basic Tools

• Web3.js, the Ethereum JavaScript API
• Ethlint, a linter for Solidity
• Hardhat. a development environment for Ethereum

Advanced Tools

• Metamask, allowing for full-featured interaction with ĐApps through the browser
• Vyper, an experimental programming language for writing smart contracts, actively developed

Learning Materials:

• The Cryptography series from Stanford on Coursera
• An excellent tutorial series on smart contracts
• A great introduction to writing full-stack blockchain-connected software in three parts, from simple voting contracts using web3 on testrpc, to token sale ĐApps built with Truffle, deployed to public networks
• The Official Ethereum tutorial on writing a decentralized app with Meteor

Blockchain IoT Open-Source Project

Finally, we invite you to learn from 2017 Toptal Open Source Grant Award Winner, the Blockchain IoT project, as it gets built.