---
# System prepended metadata

title: Week 19 at Blockfuse Labs A Battle Between Burnout and Breakthroughs

---

# Week 19 at Blockfuse Labs A Battle Between Burnout and Breakthroughs

Week 19 at Blockfuse Labs was intense, the kind of week that reminds you how demanding the tech journey can be. Somewhere between debugging smart contracts and trying to understand low-level operations, I hit a wall. The burnout was real. I even started feeling physically unwell at some point.

But looking back, I realize that week taught me as much about balance and resilience as it did about code.


**Low Level Exponentiation: Power Behind the Math**

This week, we explored low-level exponentiation, one of the most fundamental mathematical operations in blockchain systems, especially in cryptography and gas optimization.

In Solidity, exponentiation is done with the ** operator, but under the hood, it involves complex gas-cost calculations. We discussed how understanding these low-level details helps write more efficient contracts.

Here’s a simple example:
```
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract ExponentiationDemo {
    function power(uint base, uint exponent) external pure returns (uint result) {
        result = 1;
        for (uint i = 0; i < exponent; i++) {
            result *= base;
        }
    }

    // Built-in Solidity exponentiation (less gas-efficient for big numbers)
    function powerUsingOperator(uint base, uint exponent) external pure returns (uint) {
        return base ** exponent;
    }
}

```


This exercise wasn’t just about writing loops, it was about understanding how the Ethereum Virtual Machine (EVM) handles computation, and why every gas unit counts.


We also had a family game session at Blockfuse Labs, which turned out to be more refreshing than expected. After days of staring at code, that laughter and connection reminded me how vital community is in a learning environment. Tech can be isolating, but here, it never feels that way.

**Smart Contract Security and Reentrancy Attacks**

Security was another big focus this week. We examined reentrancy attacks, one of the most notorious vulnerabilities in Solidity. The 2016 DAO hack, for example, happened because of this exact exploit.

Here’s a simplified vulnerable contract we studied:

```
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract VulnerableBank {
    mapping(address => uint) public balances;

    function deposit() external payable {
        balances[msg.sender] += msg.value;
    }

    function withdraw(uint _amount) external {
        require(balances[msg.sender] >= _amount, "Insufficient balance");
        (bool success, ) = msg.sender.call{value: _amount}("");
        require(success, "Transfer failed");
        balances[msg.sender] -= _amount; // Problem: state updated after transfer
    }
}

```

And here’s the secure version, using the Checks Effects Interactions pattern to prevent reentrancy:
```

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract SecureBank {
    mapping(address => uint) public balances;

    function deposit() external payable {
        balances[msg.sender] += msg.value;
    }

    function withdraw(uint _amount) external {
        require(balances[msg.sender] >= _amount, "Insufficient balance");

        // Effects before interactions
        balances[msg.sender] -= _amount;

        // External call after state change
        (bool success, ) = msg.sender.call{value: _amount}("");
        require(success, "Transfer failed");
    }
}

```

Seeing how a few misplaced lines can open the door to catastrophic exploits made me appreciate how security is not a feature, it’s a mindset.

Security Is Just an Illusion
Coming from a Criminology and Security Studies background, I often remind my friends that security is just an illusion. No system is ever perfectly safe; every security measure is simply a delay, an obstacle meant to slow down the inevitable attempt to break it.

In blockchain, this principle holds even truer. Every contract, every audit, and every patch is part of an ongoing chess game between developers and attackers.


Week 19 taught me that progress sometimes comes wrapped in exhaustion. It’s okay to pause. It’s okay to feel burnt out. What matters is getting back up a little wiser, a little stronger, and a lot more aware of how deep the rabbit hole of learning really goes.
Burnout tested me, but breakthroughs defined me.