---
# System prepended metadata

title: WEEK EIGHTEEN

---

# WEEK EIGHTEEN

It’s hard to believe how far we’ve come. What once felt like an uncertain, uphill journey now feels like something deeply personal—proof of our growth, our resilience, and our ability to show up for ourselves and each other.

Week after week, we’ve learned, built, adapted, and pushed through. And now here we are: Week Eighteen. Still standing, still creating, still evolving. If nothing else, this week reminded me how powerful it is to finish what you started.

### Exploring Cairo and Zero-Knowledge Development

This week, one of the most exciting highlights was continuing our introduction to **Cairo**, the programming language used for writing provable programs on **StarkNet**, a Layer 2 scaling solution for Ethereum.

Cairo is quite different from the languages most of us are used to, but its power and purpose are fascinating—especially for blockchain development. Here are some of the key concepts we explored:

#### Option Types

Cairo’s `Option` type helps us safely handle cases where a value might not exist—ideal for decentralized environments.

```cairo
fn get_nickname(user_id: felt252) -> Option<felt252> {
    if user_id == 1 {
        Option::Some('Alice')
    } else {
        Option::None
    }
}

fn show_nickname(user_id: felt252) {
    match get_nickname(user_id) {
        Option::Some(name) => println!("User nickname: {}", name),
        Option::None => println!("No nickname set for this user"),
    }
}

```

#### Enums

Enums are great for modeling predefined states—such as the status of a blockchain transaction.

```cairo
enum DeliveryStatus {
    Preparing,
    OnTheWay,
    Delivered,
}

fn check_delivery(status: DeliveryStatus) {
    match status {
        DeliveryStatus::Preparing => println!("Your order is being prepared."),
        DeliveryStatus::OnTheWay => println!("Your order is on the way!"),
        DeliveryStatus::Delivered => println!("Your order has been delivered."),
    }
}

```

#### Structs

Structs group related data into custom types, which helps structure complex logic cleanly.

```cairo
struct User {
    address: felt252,
    balance: u256,
    is_active: bool,
}

```

#### Arrays

Arrays are essential for handling lists of dynamic data, like transaction histories.

```cairo
fn process_transactions(transactions: Array<u256>) -> u256 {
    let mut total = 0;
    for amount in transactions {
        total += amount;
    }
    total
}

fn main() {
    let mut transactions = array![100, 200, 300];
    let total = process_transactions(transactions);
    println!("Total transaction amount: {}", total);
}
```

### Wrapping Up Our Base Batch Hackathon Project

Alongside Cairo, our focus this week was finalizing our project for the Base Batch Hackathon. This involved:

* **Documenting** every part of the project to clearly explain our goals, approach, and implementation.
* **Creating a pitch deck** to present the product and its value clearly and effectively.
* **Recording a demo video** that provides a concise, engaging walkthrough of how our product works.

It’s been a rewarding week of learning, building, and presenting—making things real.