Examples of Blockchain Technology and the Different Types of Blockchain Codes

For almost 10 years, the bitcoin community has placed a high importance on blockchain technology. Satoshi Nakamoto designed it and it first appeared in 2008. It was designed to be a platform for Bitcoin monetary transactions at first. It has evolved into a multi-purpose public ledger capable of completing a wide range of jobs over time. You are welcome to browse through our tutorial and pick the best-fitting blockchain code example to deploy a blockchain.

With blockchain implementation, digital information may be distributed and shared in a decentralised manner. Additionally, data forgery, copying, and manipulation can be reduced. Secure transparency is a crucial blockchain feature that benefits numerous sectors' workflows and increases their productivity and efficiency.

Bitcoin was the first cryptocurrency, and it quickly grew in popularity. The overall market capitalization of Bitcoin is currently about $111 billion. Aside from Bitcoin, there are a slew of other cryptocurrencies that are now being utilised for financial transactions on blockchain platforms:

Capitalization of the market

The Different Types Of Blockchains

Many blockchains are now producing the cryptocurrencies mentioned above. Furthermore, they all have some digital worth. There are three types of blockchains now in use: public, private, and federated. Let's examine them more closely and establish their distinguishing characteristics.

Example of Blockchain Technology in the Public Sector

The majority of functions supplied by traditional financial institutions are expected to be replaced by public blockchains. This is made feasible by improved software, which alters traditional financial system approaches.

The majority of blockchains employ proof of work (PoW) consensus techniques, which are open to the public and are classified as non-permissioned. This means, in particular, that all users must:

  • This form of blockchain allows anybody to engage without any limits.

  • are able to download the source code and run a node on their own devices in order to verify the transaction procedure.

  • anyone use the network to make payments and participate in the blockchain

  • Due to transparency, users can see transaction history while being anonymous.

Bitcoin is one of the most well-known public blockchain instances, ranking alongside Ethereum and Litecoin.

These blockchain technologies have the potential to drastically alter traditional business paradigms. They also save money by removing server maintenance fees and making the deployment of decentralised apps nearly free.

Example of Private Blockchain Technology

Private blockchains address challenges such as efficiency, security, and deceit. While private blockchains do not have the same potential to disrupt established financial institutions as public blockchains, they can provide a number of other benefits.

A centralised entity has write permissions on a private blockchain. Read permissions can be made available or restricted to the degree needed. Internal firm data governance and audit are a private example of blockchain uses. As a result, public access isn't required in this instance. In a different circumstance, public access would be preferable.

Instead of sharing information, businesses choose to employ private blockchains for internal usage. As a result, only a small number of persons have access to the company's transactions.

One of the disadvantages of such a system is that it resembles a centralised one, making it more vulnerable. Private blockchains, on the other hand, outperform public blockchains in terms of scalability and regulatory compliance.

Private blockchain technology is exemplified by MONAX and Multichain.

Blockchains for private use:

  • lower expenses

  • Excess data should be reduced.

  • Streamline the documentation process

  • Reduce the number of mechanisms that must be maintained manually.

Example of Federated Blockchain Technology

The functions of a federated blockchain, also known as Consortium, are directed by a group of users. No one may meddle with the information about transactions and their verification on these blockchains. This blockchain example is quick and includes a lot of privacy options. This is demonstrated by the fact that many banks and other financial organisations employ it. The process of reaching consensus is managed by a group of nodes that have been pre-selected. For example, in order to obtain a consensus, ten out of fifteen members must sign and approve a block. It is only then that it is valid. Furthermore, federated blockchain can contain choices for public or restricted access.

Consortium blockchains include R3, EWF, and B3i.

These blockchains have the same impact as private blockchains. With federated blockchains, it is possible to:

  • reduce data redundancy and costs

  • abolition of procedures that necessitate manual management

Take a look at the table below for a comparison:

As of April 2018, the most popular blockchains were public and private. They account for 44% of all blockchain-enabled enterprises in the globe. Then there are consortium blockchains (36%), and then all other sorts of blockchains (3 percent ).

Concerns about Blockchain Development

It is critical to be aware of potential pitfalls ahead of time in order to avoid them when building a strong and effective blockchain. These concerns include security, resource management, performance/productivity efficiency, and isolation.

A Security Concern

Blockchains offer a higher level of security and anonymity. As a result, they must be extremely safe. The written code should be impenetrable to hackers and free of flaws and vulnerabilities. Because everyone can usually examine the source code, any potential issues are straightforward to spot and resolve.

Hackers, on the other hand, are also programmers. As a result, there's a good chance that blockchain will be attacked. This necessitates the creation of a sophisticated and difficult-to-tamper-with coding structure. As a result, developing and deploying a new blockchain takes time and additional effort. To better serve all users, it must be designed precisely and wisely. This work is critical because to the immutable and irreversible nature of blockchain technology.

The Problem of Resource Management

Keep in mind that the task of deploying a new blockchain is not completed in a single step. There will be more actions to take and difficulties to solve after the blockchain is implemented. As a result, keeping up with modern network requirements and demands is essential. Regardless of whether the requests are distant or local, they must be monitored and handled. To satisfy all of the network's demands, improvements will be required on a regular basis. Suitability with the most recent apps, currency acceptance, and so forth are examples.

The Problem of High Performance

Any blockchain must be extremely efficient and capable of handling a wide variety of jobs. Developers must choose the most flexible and appropriate coding language to deal with all needs, such as distributed operations or resource management, in order to ensure optimal performance. This could entail completing work in a parallel manner. Some blockchains do not have such a feature. As a result, the programmer should decide from the start which specific solutions to solve and what actions to take.

This problem may appear complicated since it involves many transactions that cannot be completed in concurrently to avoid double spending, for example. As a result, some languages are better suited to parallel processes, while others are better suited to non-parallel ones.

Isolation Problem

Isolation is used to tackle deterministic behaviour difficulties. Consider the following equation to better understand what deterministic means:

Behavior that is predetermined

If A + B = C, then A+B will always equal C, regardless of the conditions. This is what is referred to as deterministic behaviour.

Because hash functions are deterministic, the hash of A will always be H. (A).

All transactions on a blockchain must be deterministic, which means that one transaction cannot behave differently than another. The same may be said about smart-contract functionality. Each smart contract has its own set of rules that cannot be changed at any time.

If you have any questions about smart contract development, please contact Cryptoauxiliary.

You must isolate transactions or smart contracts (SCs) from non-deterministic factors in order to tackle such challenges.

Tutorial on the Blockchain Code

To code for any blockchain, developers must assess the aforementioned challenges and select the most appropriate coding language. Currently, there are a variety of approaches to code blockchain. The most common coding languages are shown here, along with a blockchain code example for each.

The most often used languages are C/C++, Go, Python, and Javascript.

Bjarne Stroustrup created C++ as one of the first programming languages. It is more versatile and efficient than C, and it is also object-oriented. C++ is structured in an OOP (Object Oriented Programming) style. As a result, the basic idea behind it is to let a programmer to write code according to his preferences using a compiler complication mechanism.

Javascript is a web programming language that is often used to create interactive webpages. With the introduction of Node.JS, a programming environment comparable to Node, one can use Google's V8 JavaScript Engine, which allows JavaScript to interface with I/O via a C++ API.

Python was invented in 1991 by Guido van Rossum, a Dutch programmer, with the goal of making code as simple and minimal as possible. As a result, it simplifies things by obviating the need for curly brackets or keywords that are replaced with white spaces. Python is a scripting language that comes with a large number of libraries. As a result, a programmer can deal with system processes without having to worry about memory management.

The language of solidity has recently gained a lot of traction. It's ideal for deploying decentralised applications or launching initial coin offerings. Solidity is a free-typed, purposefully simplified language with an ECMAScript or C++-like syntax. To learn more about how to build up and launch an ICO using Solidity, click here.

Azure is a platform that is better suited to creating apps that reflect multi-party workflows that are determined by configuration code and SCs. Azure makes development easier, accelerates up operations, and improves security and scalability.

Blockchain Example Code in C++

The “Hello World” programme in C++ is a simple example:

#include using namespace std; int main(){ cout << "Hello World!"; return 0; }

Isn't it straightforward? It's worth noting that it's where the Bitcoin blockchain is stored! The following are some of the aspects that make C++ so valuable in the blockchain community:

1. Memory Control: To address the aforementioned resource management and security difficulties, C++ aids in the complete control of the central point unit and memory. To prevent chain forks, all network nodes can accept or reject specific blocks.

2. Threading is concerned with the performance of parallelized tasks. Because of its threading ability, C++ is ideally suited to handle both parallelized and non-parallelized workloads.

3. Move semantics: one of the most useful C++ features is the ability to move content across objects rather than copying semantics.

The value of "b" does not have to be the same when using the move semantics. This is the distinction between copy and move semantics.

The primary benefit of move semantics is that you can only receive copies of particular data when you need them, which reduces code redundancy and improves efficiency significantly.

4. Compile Time Polymorphism is a trait of object-oriented programming. This property is implemented in C++ by:

By boosting system performance, the compile time polymorphism separates responsibilities in distinct functions.

5. Code Isolation: To avoid name clashes, namespace features can be entered across many programmes. It also serves as an API barrier due to C++ classes, allowing for unambiguous separation.

6. Maturity: C++ is regarded as a mature language that is updated on a regular basis. Furthermore, its functions address a variety of real-world concerns, ranging from performance profiling to trouble detection.

Blockchain Example Code in Javascript

Let's go over the fundamentals of creating a blockchain with Javascript.

In a chain of blocks, each block has a hash of the previous block. The hash is dramatically changed in the event of an attack or bad conduct, which affects the entire blockchain, freezing it and therefore removing the possibility of modifying the block.

Consider the following details when creating a block:

1. To begin, make a block. An example of blockchain code is as follows:

const SHA256 = require("crypto-js/sha256"); class Block { constructor(index, timestamp, data, previousHash = '') { this.index = index; this.previousHash = previousHash; this.timestamp = timestamp; this.data = data; this.hash = this.calculateHash(); } calculateHash() { return SHA256(this.index + this.previousHash + this.timestamp + JSON.stringify(this.data)).toString(); } }

Analysis of the Code:

  • Include the crypto-js library in your code.

  • Declare the function Object() { [native code] } that will be called when the class is instantiated. A constructor's job is to create a new instance of a class.

  • To get the block hash, hash all of the material.

  • To format block data, use the JSON.stringify function.

2. Create a blockchain by following these steps:

Create a genesis block, which is the first block on the blockchain to be invoked.



return new Block(0, “01/01/2018”, “Genesis block”, “0”);


Add other blocks. In order to connect blocks, use this function:



return this.chain[this.chain.length - 1];


addBlock(newBlock) {

newBlock.previousHash = this.getLatestBlock().hash;

newBlock.hash = newBlock.calculateHash();



In order for the new block to be regarded valid, the values of the preceding and current blocks must match.

Validate the chain, ensuring that it is stable and free of vulnerabilities.

for (let i = 1; i < this.chain.length; i++)


const currentBlock = this.chain[i];

const previousBlock = this.chain[i - 1];

if (currentBlock.hash !== currentBlock.calculateHash()) {

return false;


if (currentBlock.previousHash !== previousBlock.hash)


return false;



return true;


Finally, you can put your blockchain to use!

Python Example of a Blockchain

Python, as previously said, is a simple coding language that is easy to learn and use. Here's an example of a Python programme that says "Hello World":

‘Hello, world!' print(‘Hello, world!')

That's all there is to it. You can see how simple Python is in comparison to C++ programmes.

Let's go on to the stages of development:

1. Add a hashlib to a block to make it:

class Block: def __init__(self, index, timestamp, data, previous_hash): self.index = index self.timestamp = timestamp self.data = data self.previous_hash = previous_hash self.hash = self.hash_block() def hash_block(self): sha = hasher.sha256() sha.update(str(self.index) + str(self.timestamp) + str(self.data) + str(self.previous_hash)) return sha.hexdigest()

2. Enter datetime as date: to create a genesis block (the first on the network).

def create_genesis_block(): return Block(0, date.datetime.now(), “Genesis Block”, “0”)

3. Using the following function, make and connect the additional blocks:

def next_block(last_block): this_index = last_block.index + 1 this_timestamp = date.datetime.now() this_data = "Hey! I'm block " + str(this_index) this_hash = last_block.hash return Block(this_index, this_timestamp, this_data, this_hash)

4. The next stage is to create a blockchain:

blockchain = [create_genesis_block()]

previous_block = blockchain[0]

num_of_blocks_to_add = 15

for i in range(0, num_of_blocks_to_add):

block_to_add = next_block(previous_block)


previous_block = block_to_add

# Tell everyone about it!

print "Block #{} has been added to the blockchain!".format(block_to_add.index)

print "Hash: {}n".format(block_to_add.hash)

We've constructed a genesis block and given it the value "previous block." Then we choose a number of blocks to add and printed the total number of blocks added along with their hashes.

This is how the printout might appear:

Any further complicated features are entirely up to you!

Example Code for Solidity

Solidity is a programming language that is frequently utilised by programmers and developers for dApp deployment and ICO launches. The following is an example of code:

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;


} }

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];



return sum;


// Section 3: Killing the contract

function kill()


if (msg.sender == creator)






Now let’s take a closer look at development stages:

1. To begin, assign values by using a "while loop" to fill the integers array:

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

The value of the x integer is 0. In addition, the while loop begins at 0 and indicates the integer length limit. If you take it all the way up to 9, you'll get the following: 0,1,2,3,4,5,6,7,8,9.

2. Using a while loop and a "sum" variable, add the items of an array.

3. To refund any remaining payments to the contract originator, use the "Kill the Contract" function.

These are the major steps in creating a blockchain in Solidity. Here's where you can learn more about the Solidity language and how to make smart contracts.

Example of a Decentralized App in Azure

The Azure coding platform is the last but not least. It can also be used as an Azure blockchain example. It is mostly used for the deployment of decentralised applications.

Create a configuration file first. Its information specifies improved processes and dAPP interaction models.

To begin, open your preferred editor and create a “HelloBlockchain.json” file.

Then take the following steps:

1. Add metadata to the programme by giving it a name and a description. According to functionality, include application roles and blockchain participants:


"ApplicationName": "HelloBlockchain",

"DisplayName": "Hello, Blockchain!",

"Description": "A simple application to send request and get response",

"ApplicationRoles": [


"Name": "Requestor",

"Description": "A person sending a request."



"Name": "Responder",

"Description": "A person responding to a request"



2. Define the contract stages and actions workflows:

"Workflows": [


"Name": "HelloBlockchain",

"DisplayName": "Request Response",

"Description": "A simple workflow to send a request and receive a response.",

"Initiators": [ "Requestor" ],

"StartState": "Request",

"Properties": [


"Name": "State",

"DisplayName": "State",

"Description": "Holds the state of the contract.",

"Type": {

"Name": "state"




"Name": "Requestor",

"DisplayName": "Requestor",

"Description": "A person sending a request.",

"Type": {

"Name": "Requestor"




"Name": "Responder",

"DisplayName": "Responder",

"Description": "A person sending a response.",

"Type": {

"Name": "Responder"




"Name": "RequestMessage",

"DisplayName": "Request Message",

"Description": "A request message.",

"Type": {

"Name": "string"




"Name": "ResponseMessage",

"DisplayName": "Response Message",

"Description": "A response message.",

"Type": {

"Name": "string"




"Constructor": {

"Parameters": [


"Name": "message",

"Description": "...",

"DisplayName": "Request Message",

"Type": {

"Name": "string"