DEV Community: Masudur Rahman

What Is Blockchain? A Simple Explanation Through a Story

Masudur Rahman — Thu, 22 Oct 2026 17:41:32 +0000

No complicated terms. No coding knowledge required. Just a simple story to help you understand blockchain from the ground up.

Have you ever wondered how people can send money across the world without relying entirely on a traditional bank? Or how digital assets can be transferred and verified without a single organization controlling every record?

To understand these ideas, let's start with a simple story.

1. The Village Bank: Where the Story Begins

Imagine a small village with five friends:

Rahim
Karim
Sumon
Rakib
Jamal

They decide to create a small community bank. They don't have a bank building, a manager, or an expensive banking system. They have only one notebook.

Inside the notebook, they record everyone's balance.

Person	Balance
Rahim	$1,000
Karim	$500
Sumon	$800

One day, Rahim gives Karim $200.

They update the notebook:

Rahim → Karim = $200

Now Rahim has $800, and Karim has $700.

Everything seems fine. But there's a problem.

What happens if Rahim secretly changes the notebook and increases his balance from $800 back to $1,000?

Who can prove that he already spent $200?

If only one person controls the records, everyone else must trust that person.

This is where the idea behind blockchain begins.

2. The Solution: One Notebook Shared by Everyone

Jamal comes up with a different idea.

"Why should only one person keep the notebook? Let's give everyone a copy!"

Now, all five friends maintain their own copies of the same transaction history.

When Rahim sends $200 to Karim:

The transaction is shared with the network.
Participants check whether it follows the rules, including whether Rahim has enough money.
If the transaction is valid, it can be accepted into the shared record.
The participants update their records according to the network's rules.

Now, if Rahim secretly changes his own notebook, the other four still have their original records.

He cannot simply change his copy and expect everyone else to accept his new balance.

This is the basic idea behind a blockchain: multiple participants maintain and verify records according to agreed rules.

Real blockchain networks can involve thousands of computers, not just five friends. Their exact designs and verification processes vary.

3. Why Is It Called Blockchain?

The name has two parts:

Block + Chain = Blockchain

Imagine the village bank processes hundreds of transactions in a day.

Instead of treating every transaction as an isolated record, the system groups transactions into batches called blocks.

Each block can contain transaction data, information about the previous block, and other technical details.

Here's a simplified example.

Block 1

Rahim sends Karim $200.
Karim sends Sumon $100.
Jamal sends Rahim $50.
Block hash: A91F...

Block 2

Rahim sends Sumon $300.
Karim sends Jamal $150.
Block hash: B72C...
Previous block hash: A91F...

Block 3

More transactions.
Previous block hash: B72C...

The blocks are linked together in sequence.

Think of each block as a page in a digital record book. Each new page refers to the previous page through cryptographic information.

Together, these linked blocks form a blockchain.

Note: The hash values above are illustrative placeholders, not calculated hashes from actual transaction data.

4. What Is a Hash? Think of a Digital Fingerprint

A hash is one of the most important concepts in blockchain.

Imagine that every page in the village bank's notebook has a unique digital fingerprint.

A computer processes information using a mathematical function called a hash function. The result is a fixed-length value known as a hash.

For example, imagine this transaction:

Rahim pays Karim 200

It produces a hash represented here as:

7F3A91...

Now suppose someone changes the transaction:

Rahim pays Karim 900

The resulting hash will generally be very different:

C82D14...

These values are simplified examples, not actual computed results.

Why does this matter?

Because changing information in an earlier block can invalidate its hash and disrupt the links to subsequent blocks.

In a properly secured blockchain, an attacker would need to overcome additional cryptographic and network protections to successfully alter accepted history.

Remember three things:

A hash acts like a digital fingerprint of data.
A hash does not normally allow you to recover the original information.
A hash alone does not prove that information is true. It helps detect changes.

This is one reason blockchain records can be difficult to alter secretly.

5. What Is Consensus? How Does a Network Agree?

Let's return to our village.

Rahim now has only $500, but he tries to send Karim $900.

He tells the network, "Please record this transaction."

Should the network accept it?

The participants must follow the network's rules. If Rahim doesn't have enough funds, the transaction should be rejected.

But how do thousands of computers agree on which transactions and blocks to accept?

Blockchain networks use mechanisms called consensus mechanisms.

Two well-known examples are:

Proof of Work (PoW)

Bitcoin uses Proof of Work.

Participants known as miners compete by performing computational work to help produce blocks. This process consumes computing resources and electricity.

Proof of Stake (PoS)

Ethereum uses Proof of Stake.

Validators stake cryptocurrency and participate in proposing or validating blocks according to the network's rules.

Both mechanisms help a network agree on its records, but they operate differently and have different security and resource requirements.

Consensus is not simply a majority vote by ordinary computers. It involves specific protocols designed to help the network reach agreement.

6. Is Bitcoin the Same as Blockchain?

No. This is one of the most common misunderstandings among beginners.

Bitcoin is a cryptocurrency. Blockchain is a technology used to record transactions.

Bitcoin uses its own blockchain to maintain a public transaction history.

But blockchain technology can support more than digital money. Depending on the design, it can also support digital asset ownership, automated agreements, and other shared records.

Think of it this way:

YouTube is not the same thing as the internet. YouTube uses internet infrastructure.

Similarly, Bitcoin is not the same thing as blockchain. Bitcoin uses blockchain technology.

The analogy isn't exact, but it helps explain the relationship.

Also, not every blockchain needs to have its own cryptocurrency.

7. What Is a Crypto Wallet?

Imagine you want to send Bitcoin to a friend in another country.

You need a way to manage the cryptographic keys that authorize transactions. This is where a crypto wallet comes in.

Despite the name, a wallet does not necessarily store coins like a physical wallet stores cash. It manages the keys used to access and control digital assets recorded on a blockchain.

Two important concepts are:

Public address: An address you can share with someone who wants to send you cryptocurrency.

Private key: A secret cryptographic key used to authorize transactions.

Think of your public address as a destination where someone can send funds, and your private key as a highly sensitive key that allows you to authorize certain actions.

Wallets use cryptographic signatures to prove that a transaction was authorized by someone who controls the relevant key.

Important security rule: Never share your private key or secret recovery phrase. If someone gains control of them, they may be able to steal your assets. Blockchain transactions are also often difficult or impossible to reverse.

8. What Is a Smart Contract? Meet the Digital Worker

Now imagine Sumon runs an online business.

He wants a system that automatically performs certain actions when predefined conditions are met.

A developer creates a smart contract.

A smart contract is a program deployed on a blockchain that executes according to its programmed rules.

Think of a digital vending machine.

A user submits a transaction.
The program checks the required conditions.
If the conditions are satisfied, the code performs the permitted action.
The resulting state change is recorded on the blockchain.

Smart contracts can support many applications, including:

Transferring digital assets.
Executing certain cryptocurrency payments.
Decentralized lending and borrowing.
Creating and transferring NFTs.
Managing rules for decentralized applications.

However, smart contracts are not magic.

They cannot automatically verify every real-world event. For example, confirming that a physical product was delivered may require an external service or a trusted data source.

Smart contract bugs can also cause serious problems, so security testing is essential.

9. What Is Web3?

Now we have learned three important concepts:

Blockchain: A system for maintaining and verifying shared digital records.
Cryptocurrency: A digital asset that can be transferred or recorded using blockchain technology.
Smart contract: A program that executes predefined rules on a blockchain.

Together with other technologies, these can be used to build Web3 applications.

Examples include:

Digital asset marketplaces.
NFT platforms.
Blockchain-based games.
Decentralized finance (DeFi) applications.
Applications that use crypto wallets for login or transaction approval.

If you already know React or Next.js, you can use those technologies to build the user interface of a Web3 application.

The frontend may connect to a wallet, interact with a smart contract, and communicate with a blockchain through an RPC provider.

But Web3 applications still need ordinary software engineering.

Many use conventional APIs, databases, cloud infrastructure, and backend services alongside blockchain components.

Web3 does not automatically mean that every part of an application is decentralized.

10. Blockchain vs. Traditional Database

Does every application need blockchain?

Absolutely not.

Consider a regular online store.

You need to manage products, customers, orders, inventory, and payments. A traditional database is usually the more practical choice.

Compare the two approaches:

Feature	Traditional Database	Blockchain
Control	Often managed by one organization	Can be shared across multiple independent participants
Changing records	Usually straightforward for authorized users	Altering accepted history can be difficult
Performance	Often faster for ordinary application workloads	Depends on the network and transaction type
Cost	Often less expensive for conventional applications	May involve transaction fees and additional infrastructure
Best suited for	E-commerce, SaaS, customer data	Shared verification, digital assets, and systems that need reduced reliance on a single record keeper

Blockchain is particularly useful when multiple parties need to verify shared records and do not want to rely entirely on one organization.

If a normal database solves the problem efficiently, adding blockchain may introduce unnecessary complexity, cost, and security risks.

Choose the technology based on the problem, not the hype.

11. Test Your Knowledge: A Quick Blockchain Quiz

Let's check what you've learned.

Question 1: What does a block represent in a blockchain?

A. A computer

B. A group of transactions or other data

C. A cryptocurrency

Correct answer: B. A block contains a batch of data, often including transactions.

Question 2: What is the main purpose of a hash?

A. To add money to an account

B. To increase internet speed

C. To create a digital fingerprint of data

Correct answer: C. A hash helps identify changes in data.

Question 3: What is the relationship between Bitcoin and blockchain?

A. Bitcoin is a cryptocurrency that uses blockchain technology.

B. They are exactly the same thing.

C. Blockchain is just an application for buying Bitcoin.

Correct answer: A. Bitcoin is a cryptocurrency, while blockchain is the underlying record-keeping technology it uses.

Question 4: What is a consensus mechanism?

A. A way to design websites

B. A protocol that helps a blockchain network agree on accepted records

C. A type of crypto wallet

Correct answer: B.

Question 5: What is a smart contract?

A. A legal document stored in a folder

B. A program that executes predefined rules on a blockchain

C. A password for a wallet

Correct answer: B.

Question 6: Does every application need blockchain?

A. Yes, because blockchain is always more secure.

B. No, traditional databases are often better for ordinary applications.

C. Yes, if the application has a frontend.

Correct answer: B. Blockchain is a useful tool, not a universal replacement for databases.

12. What Should You Learn Next?

If you want to understand blockchain more deeply or become a Web3 developer, follow this learning path:

Blockchain fundamentals: Blocks, chains, hashes, nodes, and consensus.
Cryptography basics: Public keys, private keys, and digital signatures.
Bitcoin and Ethereum: Understand their purposes and how they differ.
Smart contracts: Learn Solidity and build simple contracts.
Web3 development: Explore wallet integration, blockchain RPCs, and smart contract interaction using React or Next.js.

You don't need to master everything in one day. Start with the concepts, understand why they exist, and then explore how developers implement them.

Recommended Resources

Investopedia — Blockchain: https://www.investopedia.com/terms/b/blockchain.asp
AWS — Web3: https://aws.amazon.com/web3/
Blockchain explained through video: https://www.youtube.com/watch?v=SSo_EIwHSd4

The Big Picture

Let's return to the village bank one last time.

Five friends wanted a trustworthy way to record transactions. Instead of relying entirely on one notebook controlled by one person, they imagined a shared record that everyone could verify according to common rules.

That simple story captures the core idea behind blockchain.

In real systems, cryptography links records, network protocols determine which transactions are accepted, and consensus mechanisms help participants agree on the blockchain's state.

Blockchain is a shared digital record-keeping system in which data is organized into linked blocks and new records are verified according to the network's rules.

It is more than cryptocurrency. It is a technology that can support digital ownership, automated agreements, and applications where shared verification matters.

And now, you have the foundation to understand Bitcoin, Ethereum, mining, wallets, smart contracts, and Web3.

If this explanation helped you understand blockchain, share it with someone who is just getting started.

Blockchain #Web3 #Bitcoin #Ethereum #SmartContracts #Technology #LearnBlockchain #SoftwareDevelopment

Masudur Rahman
Frontend Engineer | React Native Developer | Shopify Expert
Email: madhnagar@gmail.com
WhatsApp: +8801709036155

Mastering Linked Lists in Data Structures and Algorithms: A Step-by-Step Guide

Masudur Rahman — Wed, 28 Aug 2024 19:03:26 +0000

Linked lists are one of computer science's most fundamental data structures, serving as a building block for more complex structures like stacks, queues, and graphs. If you’re preparing for coding interviews or just diving deep into data structures and algorithms (DSA), mastering linked lists is necessary. In this article, I’ll walk you through a structured approach to learning linked lists.

1. Lay the Foundation: Understand Basic Data Structures

Before jumping into linked lists, it’s crucial to have a solid understanding of basic data structures like arrays, stacks, and queues. This foundation will help you grasp why linked lists are used and how they solve specific problems better than other structures.

2. Start Simple: Singly Linked Lists

a. Grasp the Concept

A singly linked list is a collection of nodes where each node contains two parts: data and a reference (or pointer) to the next node in the sequence. The last node points to null, signifying the end of the list. Unlike arrays, linked lists do not store elements in contiguous memory locations, making them dynamic in size and efficient for insertions and deletions.

b. Implement Basic Operations

Begin by implementing basic operations like traversal, insertion, and deletion in a singly linked list. Here’s what you should focus on:

Traversal: Iterate through the list, starting from the head, and visit each node until you reach the end.
Insertion: Learn to insert a node at the beginning, end, or after a specific node.
Deletion: Practice deleting a node from the beginning, end, or by its value.

c. Code It Out

Choose a programming language you’re comfortable with (JavaScript, Python, Java, etc.) and start coding these basic operations. For example, here’s how you might implement a singly linked list in JavaScript:

class Node {
    constructor(data) {
        this.data = data;
        this.next = null;
    }
}

class LinkedList {
    constructor() {
        this.head = null;
    }

    // Insert at the beginning
    insertAtBeginning(newData) {
        const newNode = new Node(newData);
        newNode.next = this.head;
        this.head = newNode;
    }

    // Insert at the end
    insertAtEnd(newData) {
        const newNode = new Node(newData);
        if (!this.head) {
            this.head = newNode;
            return;
        }
        let last = this.head;
        while (last.next) {
            last = last.next;
        }
        last.next = newNode;
    }

    // Traverse the list
    traverse() {
        let current = this.head;
        while (current) {
            console.log(current.data);
            current = current.next;
        }
    }
}

3. Level Up: Dive into Doubly Linked Lists

a. Understand the Difference

In a doubly linked list, each node contains two references: one to the next node and another to the previous node. This bidirectional structure allows traversal in both directions, making it more versatile than a singly linked list.

b. Implement and Compare

After understanding the structure, implement basic operations like insertion and deletion. Compare how operations differ from singly linked lists, especially how pointers are managed when inserting or deleting nodes.

4. Go Circular: Explore Circular Linked Lists

a. Grasp the Circular Structure

Circular linked lists are an extension of regular linked lists where the last node points back to the first node, forming a circle. This structure is useful in scenarios like implementing round-robin scheduling.

b. Practice Operations

Implement traversal, insertion, and deletion in a circular linked list. Pay close attention to maintaining the circular nature of the list during these operations.

5. Tackle Advanced Topics

a. Recursive Linked List Operations

Once you’re comfortable with iterative operations, try implementing them recursively. For example, practice reversing a linked list using recursion.

b. Problem-Solving with Linked Lists

Linked lists are a common topic in coding interviews, so practice solving problems like:

Finding the middle element of a linked list.
Detecting and removing loops in a linked list.
Merging two sorted linked lists.
Reversing a linked list in groups of k nodes.

Use platforms like LeetCode, HackerRank, or Codeforces for practice.

6. Understand Memory Management and Complexity

a. Memory Considerations

Linked lists use dynamic memory allocation, which can be more space-efficient than arrays when dealing with unpredictable data sizes. However, each node’s pointer adds to the memory overhead, so understanding this trade-off is essential.

b. Analyze Time Complexity

Analyze the time complexity of basic operations like insertion, deletion, and search in both singly and doubly linked lists. Understand why operations in a linked list typically take O(n) time and how this compares to array operations.

7. Real-World Applications of Linked Lists

a. Implement Data Structures

Linked lists are often used to implement other data structures like stacks, queues, and hash tables (using chaining). Practice building these structures using linked lists.

b. Explore Case Studies

Study how linked lists are used in real-world applications like memory management in operating systems, undo functionality in text editors, and adjacency lists in graphs.

8. Build Projects and Contribute to Open Source

a. Create Your Own Data Structure

Try building a custom data structure based on linked lists, such as a playlist manager or a memory allocator. This will deepen your understanding and give you practical experience.

b. Contribute to Open-Source Projects

Look for open-source projects that use linked lists and contribute to them. This will expose you to real-world codebases and enhance your problem-solving skills.

9. Review, Revise, and Teach

a. Regular Practice

Regularly revisit linked list concepts and problems to reinforce your knowledge. Consistency is key to mastering DSA.

b. Teach and Share

Explaining concepts to others is one of the best ways to solidify your understanding. Consider writing blog posts or teaching linked list concepts to peers. Sharing your knowledge on platforms like Dev Community can also help you connect with others and learn from their experiences.

10. Explore Advanced Linked List Variations

Once you’ve mastered the basics, explore more advanced variations like:

Skip Lists: A data structure that allows faster search within an ordered sequence of elements.
XOR Linked Lists: A memory-efficient doubly linked list that uses bitwise XOR to store both the previous and next pointers in one variable.

Conclusion

Mastering linked lists is a journey that involves understanding concepts, implementing them in code, solving problems, and applying what you’ve learned in real-world scenarios. By following this step-by-step guide, you’ll build a deep and comprehensive understanding of linked lists, laying a strong foundation for more advanced data structures and algorithms.

Happy coding!

Mastering Error Handling in JavaScript: The Power of try...catch

Masudur Rahman — Tue, 20 Aug 2024 17:03:41 +0000

JavaScript is one of the most popular programming languages today, powering everything from dynamic websites to full-fledged web applications. Whether you're a beginner or an experienced developer, understanding how to handle errors is crucial for writing robust, reliable code. A key tool for managing JavaScript errors is the try...catch statement.

In this article, we'll explore the try...catch statement in depth, understand how it works, and see how you can use it to gracefully handle errors in your JavaScript applications.

Table of Contents:

Introduction to Error Handling
Understanding try...catch
Basic Structure of try...catch
Real-World Example
Common Mistakes and Best Practices
Advanced Usage of try...catch
Conclusion

1. Introduction to Error Handling
In any programming language, errors are inevitable. They can arise due to various reasons, such as incorrect user input, network failures, or bugs in the code. If not properly handled, these errors can cause your application to crash or behave unpredictably, leading to a poor user experience.

Error handling allows you to manage these unexpected situations gracefully, ensuring that your application continues to function correctly even when things go wrong. In JavaScript, the try...catch statement is one of the primary mechanisms for handling errors.

Understanding try...catch
The try...catch statement is used to handle exceptions in JavaScript. Exceptions are runtime errors that occur during the execution of a program. When an exception occurs within the try block, the program stops executing the subsequent lines in the try block and jumps directly to the catch block, where the error can be handled.
Basic Structure of try...catch
The basic syntax of a try...catch statement is as follows:

try {
    // Code that may throw an error
} catch (error) {
    // Code to handle the error
}

Let's break down the components:

try block: This block contains the code that you want to monitor for errors. If an error occurs, it is immediately thrown and the remaining code in the try block is skipped.
catchblock: This block is executed only if an error is thrown in the try block. The catch block has access to the error object, which contains information about the error that occurred.

Here’s a simple example to illustrate:

try {
    let result = someUndefinedFunction(); // This will throw an error
    console.log(result);
} catch (error) {
    console.log("An error occurred:", error.message);
}

In this example, since **someUndefinedFunction **is not defined, an error is thrown. The catchblock catches the error and logs an appropriate message.

4. Real-World Example
Consider a scenario where you are building a web application that fetches data from an external API. There could be various reasons why the API request might fail—network issues, invalid URLs, server errors, etc. Here's how you could handle such errors using try...catch:

async function fetchData() {
    try {
        let response = await fetch('https://api.example.com/data');

        // Check if the response is not OK (status code 200-299)
        if (!response.ok) {
            throw new Error(`HTTP error! status: ${response.status}`);
        }

        let data = await response.json();
        console.log("Data fetched successfully:", data);
    } catch (error) {
        console.log("Failed to fetch data:", error.message);
        // Additional error handling logic, like showing a user-friendly message
    }
}

fetchData();

5. Common Mistakes and Best Practices
While try...catch is a powerful tool, it’s important to use it correctly to avoid common pitfalls. Here are some best practices to keep in mind:

Do not overuse try...catch: It’s tempting to wrap every function call in a try...catch block, but this can lead to unnecessarily complex code. Use try...catch only where it’s needed, such as around code that is prone to runtime errors.
Handle specific errors: The catch block catches all exceptions by default, but sometimes it’s better to handle specific errors. You can achieve this by checking the properties of the error object:

try {
    // some code
} catch (error) {
    if (error instanceof TypeError) {
        // handle TypeError
    } else if (error instanceof ReferenceError) {
        // handle ReferenceError
    } else {
        // handle other types of errors
    }
}

*Avoid catching synchronous errors with try...catch:
In some cases, it’s better to catch errors as soon as they occur rather than wrapping a large block of code in a try...catch. This makes debugging easier and helps you identify the root cause of the error.
Logging errors:
Always log or report errors so that you can monitor the health of your application and address issues promptly.
Re-throwing errors:
Sometimes, after handling an error, you may want to propagate it up the call stack. You can do this by re-throwing the error:

try {
    // some code
} catch (error) {
    // handle the error
    throw error; // re-throw the error
}

6. Advanced Usage of try...catch

a) The finallyBlock
JavaScript also provides a finallyblock that you can use with try...catch. The finallyblock is executed after the try-and-catch blocks, regardless of whether an error was thrown or not. This is useful for cleaning up resources, such as closing file streams or clearing timers:

try {
    // Code that may throw an error
} catch (error) {
    console.log("An error occurred:", error.message);
} finally {
    console.log("This code runs regardless of an error.");
}

b) Using try...catch with Asynchronous Code
While try...catch works well with synchronous code, handling errors in asynchronous code (e.g., promises, async/await) requires special consideration. Here’s how you can handle errors in asynchronous code using async/await:

async function getData() {
    try {
        const response = await fetch('https://api.example.com/data');
        const data = await response.json();
        console.log(data);
    } catch (error) {
        console.error('Error fetching data:', error);
    }
}

Alternatively, when using promises directly, you can handle errors with .catch():

fetch('https://api.example.com/data')
    .then(response => response.json())
    .then(data => console.log(data))
    .catch(error => console.error('Error fetching data:', error));

7. Conclusion
Understanding and using try...catch effectively is crucial for writing reliable and maintainable JavaScript applications. It allows you to handle errors gracefully, ensuring that your application can recover from unexpected issues without crashing or causing a poor user experience.

By following the best practices and using advanced techniques like the finallyblock and error handling in asynchronous code, you can take your error-handling skills to the next level.

Whether you're just starting with JavaScript or you're an experienced developer, mastering try...catch is an essential step toward becoming a proficient JavaScript developer. As you continue to write and maintain code, you'll find that proper error handling not only makes your applications more robust but also easier to debug and maintain.

Happy coding!

Feel free to share this article with others in the developer community to help them understand the importance of try...catch and how to use it effectively in their projects.

How to resolve react-select TypeScript error?

Masudur Rahman — Fri, 29 Mar 2024 19:41:31 +0000

Mar 29 '24 Comments: 1 Answers: 0

import React, { useState } from 'react'
import { Theme } from '@/styles';
import Select, { components, DropdownIndicatorProps, PropsValue } from 'react-select';
import { TbCaretUpDownFilled } from 'react-icons/tb';

const DropdownIndicator = (props: DropdownIndicatorProps<true>) => (
  <components.DropdownIndicator {...props}>
    <TbCaretUpDownFilled />
  </components.DropdownIndicator>
);

type OptionType = {
  value: string;
  label: string;
};

…

Open Full Question

React with TypeScript and Testing App..!

Masudur Rahman — Fri, 08 Apr 2022 21:52:09 +0000

Hi, devs,
I hope you are well. I trying to build a react app using TypeScript (ES6), React, and Redux. (I am NEW to write test cases for React app). And I would like to write tests case for each and every component (Automated unit/integration tests and static code checking and formatting)

here is the visual representation...

to write test cases for this application, what should have in mind!

for example what/which area you will cover to write a test case for an input-field and button components?

HappyCoding...:)