My Web3 Journey at She on Chain Bootcamp: From Beginner to Blockchain Builder

🌐 Ever wondered what Web3 is all about? I did too! That's why I joined the RiseIn She on Chain Bootcamp—a 30-day immersive program designed to introduce women to blockchain and Web3 development. This experience has been nothing short of transformative! In this blog, I'll take you through my journey, the core concepts I learned, and how I evolved from a curious beginner to a confident blockchain builder. Buckle up, because Web3 is truly the future of the internet!

---

🚀 Understanding Web3: The Internet’s Next Evolution

What is Web3?

You've probably heard the term "Web3" floating around, but what does it mean?

Web3 represents the third phase of the internet’s evolution. Let’s break it down:

• Web1 (1990s - Early 2000s): The read-only internet. Websites were static, and users could only consume content.

• Web2 (2000s - Present): The interactive and social web. Platforms like Facebook, YouTube, and Twitter enabled user-generated content, but companies controlled user data.

• Web3 (Emerging Era): A decentralized internet where users have ownership and control over their data, powered by blockchain technology.

In Web3, rather than relying on centralized authorities like Google or Facebook, individuals own their digital identities and assets. This shift is crucial because it promotes privacy, security, and autonomy in the digital world.

The Backbone of Web3: Blockchain

Blockchain is the fundamental technology behind Web3. Imagine it as an open, digital ledger that records transactions in a transparent, secure, and immutable way. But how does it work?

• Decentralization: Unlike traditional databases controlled by a single entity, blockchain is maintained by a distributed network of nodes (computers).

• Transparency: Every transaction is recorded and visible to the public, making fraud nearly impossible.

• Immutability: Once data is recorded on the blockchain, it cannot be altered, ensuring security and trust.

Key Web3 Concepts Explained

Let’s explore some foundational Web3 concepts:

• Blockchain: A decentralized digital ledger that stores transaction data securely across multiple computers.

• Decentralization: Shifting control from central authorities to individuals and distributed networks.

• Nodes: Computers participating in maintaining and securing the blockchain network.

• Smart Contracts: Self-executing programs stored on the blockchain that trigger actions when conditions are met.

• Mining & Staking: Methods used to validate transactions and secure blockchain networks.

• Cryptocurrency: Digital assets used for decentralized transactions.

• NFTs (Fungible & Non-Fungible Tokens): Digital assets representing ownership of unique (non-fungible) or interchangeable (fungible) items.

• Wallets: Digital tools that store and manage cryptocurrencies and allow interaction with blockchain networks.

• Gas Fees: Small fees paid for processing transactions on the blockchain.

• Consensus Mechanisms: Methods like Proof of Work (PoW) and Proof of Stake (PoS) that validate transactions.

• dApps (Decentralized Apps): Applications built on blockchain rather than traditional servers.

---

💻 Front-End Development for Web3: Bridging UI with Blockchain

Learning the Essentials: HTML, CSS, JavaScript & React.js

After understanding blockchain fundamentals, it was time to build! We started with front-end development, the layer users interact with. Here are the core technologies we used:

• HTML: The foundation of web pages.

• CSS: For styling and making the app visually appealing.

• JavaScript: Adding interactivity to the application.

• React.js: A powerful JavaScript library for building dynamic and responsive UI components.

Integrating Web3 with the Front-End

Traditional web applications communicate with centralized servers, but Web3 apps (dApps) need to interact directly with the blockchain. To bridge the gap, we used:

• Web3.js & Ethers.js: JavaScript libraries that allow dApps to interact with the Ethereum blockchain.

• MetaMask: A browser extension that acts as a crypto wallet and connects users to the blockchain.

• Alchemy & Infura: Web3 infrastructure providers that enable applications to interact with blockchain nodes.

With these tools, we learned how to:

✔️ Connect dApps to blockchain wallets like MetaMask
✔️ Fetch and display blockchain data in real-time
✔️ Allow users to send transactions and interact with smart contracts
✔️ Manage asynchronous processes efficiently using state management

---

🔑 Web3 Security, Smart Contracts & Consensus Mechanisms

Understanding Smart Contracts

Smart contracts are the backbone of blockchain applications. These are pieces of code stored on the blockchain that execute transactions automatically when predetermined conditions are met—no intermediaries required!

We wrote our first smart contract in Solidity, the programming language for Ethereum smart contracts. This was a game-changer for me because it allowed me to understand how blockchain logic works.

Security & Digital Signatures

Web3 security is crucial. Every blockchain transaction requires digital signatures to ensure authenticity. These signatures verify that the transaction was indeed signed by the rightful owner, making transactions highly secure and tamper-proof.

Proof of Work (PoW) vs. Proof of Stake (PoS)

Two main mechanisms secure blockchain networks:

🐹 Proof of Work (PoW): Used in Bitcoin, requires miners to solve complex mathematical puzzles to validate transactions.
🐹 Proof of Stake (PoS): Used in Ethereum 2.0, selects validators based on the amount of cryptocurrency they stake, making it more energy-efficient than PoW.

Layer 2 Solutions & Non-EVM Chains

To address scalability issues, we explored:

• Layer 2 solutions (Polygon, Optimism): Speed up transactions and reduce fees.

• Non-EVM Chains (Aptos, Stellar): Offer alternative blockchain infrastructures with unique benefits.

---

🗂 Fourth Workshop: Writing and Deploying Smart Contracts on Remix IDE

In the fourth workshop, we wrote and deployed our first Solidity smart contract using Remix IDE. Here’s the code we implemented:

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

contract SimpleStorage{
    uint favNumber;

    struct PeopleFavNumberStruct {
        string name;
        uint favNum;
    }

    PeopleFavNumberStruct[] public arrayPeopleFavNumber;

    function store(uint _favNumber) public{
        favNumber=_favNumber;
    }

    function retrieve() public view returns(uint){
        return favNumber;
    }

    function addPeople(string memory _name, uint _favNum) public{
        arrayPeopleFavNumber.push(PeopleFavNumberStruct(_name, _favNum));
    }
}

We deployed the contract on Remix IDE, tested it by storing and retrieving values, and analyzed how smart contracts function on the blockchain. We also explored how Solidity handles different data types, memory management, and transaction execution to understand the inner workings of Ethereum smart contracts.
I took some notes as we were writing the code:

📌 Some Solidity Data Types & Terminologies

1️⃣ Value Types (Basic Data Types)

• uint (Unsigned Integer) – Only holds non-negative values (0 and positive numbers). You can specify the size, e.g., uint8, uint16, uint256 (default).

• int (Signed Integer) – Can store both positive and negative values, also with size variations like int8, int16, int256 (default).

• bool (Boolean) – Stores true or false, useful for conditional logic.

• bytes – A fixed-size array of bytes (bytes1 to bytes32). More gas-efficient than string for small data.

• string – Stores text but is less efficient than bytes.

• address – Stores Ethereum addresses (0xabc...123). Used to identify accounts and smart contracts.

• address payable – Same as address, but allows sending/receiving Ether.

2️⃣ Reference Types (More Complex Data Structures)

• Arrays – Fixed-size (uint[5] numbers;) or dynamic (uint[] numbers;) lists of values.

• Structs – Custom types grouping multiple variables.

  • Example:

      struct Student {
          string name;
          uint age;
      }
    

3️⃣ Special Data Types

• Function – Stores function references for logic execution.

  • Example:

      function myFunction() public pure returns (string memory) {
          return "Hello, Solidity!";
      }
    

---

🌍 Final Thoughts: Web3 is the Future

Web3 is revolutionizing digital ownership, security, and decentralization. If you’ve ever been curious about blockchain, now is the perfect time to start learning! The She on Chain Bootcamp gave me the foundation I needed, and I can’t wait to continue exploring the endless possibilities of Web3.

Web3 is not just a trend; it’s a paradigm shift toward a decentralized future. The sooner we embrace and understand it, the better prepared we’ll be for what’s to come.

📢 Now it’s your turn! Let’s build this future together! 🚀✨