Notable Examples of Blockchain Applications
Blockchain has been overhyped recently, but distributed-ledger technology reduces risk and worry by carrying out out regular maintenance of databases and statistics.. New solutions are being discovered daily. Blockchain application development offers various solutions in a vast array of industries: financial, gaming, voting, storage, etc.
The first famous financial dApp was Bitcoin. It was used to simplify money operations and transactions while eliminating intermediaries. However, Bitcoin blockchain is rarely used nowadays for building new dApps. Moreover, more and more dApps built on the Bitcoin network are shifting to the Ethereum blockchain.
Ethereum is the most widespread platform for developing dApps, and the most famous dApps built on Ethereum are:
- CryptoKitties, a game on blockchain for breeding and collecting digital cats
- Exodus, a software for managing blockchain digital assets
- Augur, a P2P prediction market
- Gnosis, a prediction market platform for forecasting
- Golem, a decentralized supercomputer for sharing computer power
- Storj, a decentralized cloud storage
- Status, an application for Ethereum ecosystem access
According to the State of the Dapps ranking, the most popular of the dApps are token exchanges, crypto games, P2P marketplace, etc:
There are dozens of tutorials on how to develop a blockchain application, including video tutorials, but the first thing to investigate is the main characteristics of decentralized applications.
What Makes a True DApp?
A decentralized application (DApp, dApp, or dapp) is open-source software that is developed on the blockchain. DApps connect both sides of the market, either as a service provider and consumer or buyer and seller.
A dApp is developed on the backend, and is a decentralized network. DApps aren’t controlled by an authority or a person, and here, you can observe a huge distinction in the principle of work of a simple centralized application and a decentralized one.
The most essential constituents that make up a true dApp include:
- incentivizing validators
Here is how the principle of the DApps workflow looks:
Types of DApps
Let us consider the three types of dApps based on the Ethereum blockchain. According to the Ethereum white paper, dApps are split into:
- financial applications, which are used to interact with smart contracts using Ethereum
- semi-financial applications, which use some information and data (external “oracles”) along with finances
- Non-financial applications, which are used for governance or voting and aren’t engaged in financial operations
Let’s move on to the process of developing a blockchain application.
Step-By-Step DApp Development
Blockchain application development should take as much time as needed to finish all the processes with robust confidence in project security. Pay attention to how blockchain can upgrade your business and whether or not it meets all the requirements.
Let’s check out the main constituents of a risk-free blockchain migration and dApp development.
Identify the Problem and Find a Suitable Solution
So, you’ve decided to create your own dApp based on the blockchain platform. Did you manage to find the right solution? Did you investigate the target field of work and the market demand?
The first thing to start with is to define the type of blockchain for your specific type of business or startup.
For instance, a public blockchain is suitable for payment processes. A private blockchain is used within one organization to control business processes. A hybrid consortium blockchain guarantees privacy for transactions, but it is not as centralized as a private blockchain.
Examine thoroughly the main distinctions between the types of blockchain and make a wise decision. Your business logic should be compatible with your expectations, resources, and abilities.
It is important to add that each solution will present a company with different operational costs and amounts of time needed for the execution of transactions. For example, on a public blockchain, it will depend upon utilization of the platform by other users, in private – from internal capacities, etc.
By the way, instead of building a brand-new blockchain, you can use pre-existing platforms like Ethereum, Hyperledger (Fabric, Sawtooth), IOTA (the Tangle), etc.
The next steps are the white paper release and roadmap definition. Your white paper should be academic. Along with this, it is beneficial to release certain other kinds of documents:
- yellow paper (technical document)
- compliance and risk management
For instance, the Ethereum Yellow Paper contains definitions of the transaction nonce, gas price, gas limit, value, etc; the constituents of a block; a hash function, message call; fees; technical terminology, etc.
The roadmap should contain prototype releases (alpha and beta versions) as well as the product launch defined dates. The workflow should contain testing, test net deployment, main net deployment, and all the intermittent steps.
Here are the main constituents of the roadmap plan:
Now it’s time to discuss the process of building a consensus protocol. By creating a proof of concept, a team can demonstrate the practical use and efficiency of their project.
You can try to create your own consensus mechanism in order to meet all project needs and engage more investors or stakeholders by offering a new and powerful solution.
Developing your own consensus protocol, though, means building a blockchain from the scratch. That is why we could use existing solutions (PoW or PoA, which are supported by Ethereum, or others).
Usually, PoC development consists of a theoretical build-up, building a prototype, and MVP (which stands for “minimum viable product”):
For instance, the supply-chain project VeChain has developed their own VeChainThor blockchain, or Blockchain X, which uses the Proof of Authority consensus protocol. The main principle is that if you are a stakeholder of VeChain, you are a participant in the 101 authority masternodes that run the VeChainThor software. PoA is compensating between a centralized and decentralized system.
Or you can simply choose between the existing ones:
- Proof of Work
- Proof of Stake
- Proof of Elapsed Time
- Byzantine Fault Tolerance
- Federated Byzantine Agreement
- Delegated Proof of Stake (DPoS)
- Practical Byzantine Fault Tolerance (PBFT)
- Proof of Authority
To demonstrate, for PoWs used to reach consensus, a node checks whether the miner has finished his or her computations. It uses the SHA-256 function. The miner will be able to validate the block if he or she has enough power for computation. Now, miners create “mining pools” in order to have enough resources for mining.
PoS is an alternative consensus mechanism, the principle of which is stake. The amount of stake defines which node will be able to mine the next block. The more stake you have, the more chances you’ll have to be the miner of the next block.
Quick Hacks for Smart-Contract Deployment
The first way to develop a smart contract quickly is to install the Solidity compiler (solc) with npm.
- Download Node.js and npm
- Install solc with
npm install -g solc
- Install Geth (go-ethereum)
- Install homebrew and geth:
brew tap ethereum/ethereum
brew install ethereum
Or you can use Truffle, installing it with the following commands:
npm install -g truffle
The simplest way to interact with dApps and smart contracts is to use Metamask. This is both a wallet and a source-code compiler, which allows users to call the functions of a smart contract and execute transactions or other operations.
After creating your smart contract, you should deploy it on a test network for the bug definition process. By all means, schedule a smart-contract audit with third-party involvement. You can find lots of service providers offering these kinds of fraud prevention to make your SC hack-resistant.
Back End: Building APIs
Behind every dApp stands its tokens, which help users to employ the app’s services. Tokens are used for rewards systems and the mining process.
In order to communicate using blockchain, a developer uses APIs (which stands for Application Programming Interface). The principle of API is as follows: it receives messages from the server and sends a response back.
When using Solidity programming language, be ready to use the following tools:
- IntelliJ IDEA plugin
- Visual Studio Extension
- Package for SublimeText — Solidity language syntax
- Atom Solidity Linter
- Visual Studio Code extension
- Emacs Solidity
- Vim Solidity
- Vim Syntastic
Let’s examine the development of your dApp front end. You should start with design and choosing an appropriate programming language and databases.
The most popular JS library is Web3.js, which provides the ability to communicate with nodes. It is used for :
- performing transactions
- managing user accounts
- smart-contract interaction
Mist or Metamask initially installs Web3, so there will be no need to activate it.
With the help of Truffle, you can migrate the interface with smart contracts with the library (truffle contract).
To launch a dApp, you can use IPFS to go online:
- Install IPFS
- Execute the following commands:
Create a node: ipfs daemon
Get peers: ipfs swarm peers
Add your dist to the network: ipfs add -r dist/
Publish: ipfs name publish
To interact with your dApp, use the Metamask Chrome browser extension, first on a test network.
Check out this list of the best tools for blockchain app development:
- MIST/ Ethereum Wallet (for digital asset storage, transactions, and payment performance)
- Geth (for setting up your own node)
- Truffle (development tools for compiling, testing, and deploying a dApp)
- Web3.js (an interface for blockchain interaction)
- Solc (for translating a smart contract code into a bytecode)
- BlockApps (API endpoints)
- Zeppelin (a library for smart-contract functionality)
Now, your dApp is ready for a custom domain.
According to State of the DApps statistics, the most prosperous industries for dApp launch are gaming, exchanges, and finance. The total number of dApps has already reached 1,663.
When creating a dApp, you could face lots of challenges: multiple transactions, failed operations, high fees, lengthy transaction performance, etc. — but if all the principal steps are predefined and thoroughly worked out, success is guaranteed.
Go launch a killer dApp!