---

Master Health Statistics in Cairo: Complete Learning Path

This comprehensive guide provides a deep dive into the Health Statistics module from the exclusive kodikra.com curriculum. You will learn to manipulate data, implement control flow, and use core Cairo data structures to solve a practical data analysis problem, a critical skill for any StarkNet developer.

---

You're staring at a new project brief. The goal: build a decentralized health analytics platform on StarkNet. The first task seems simple enough—process a list of anonymous patient records and generate a basic statistical report. But as you open your editor, the reality hits you. This isn't just about looping through data. This is about doing it efficiently, verifiably, and within the constraints of a blockchain environment. Every operation costs gas, and every line of code must be robust and secure.

This feeling of turning a simple concept into complex, production-ready code is a common hurdle for developers entering the world of verifiable computation. The gap between knowing Cairo's syntax and applying it to solve real-world data problems can feel vast. But what if you could bridge that gap with a single, focused challenge? This guide is your bridge. We will walk you through every step of the Health Statistics module, transforming you from someone who knows Cairo to someone who can use Cairo to build meaningful applications.

---

What is the Health Statistics Module?

The Health Statistics module is a cornerstone of the kodikra Cairo learning path. It's designed as a practical, hands-on challenge that simulates a common real-world programming task: data processing and aggregation. At its core, the module asks you to write a Cairo function that takes a collection of patient data and returns a summary report.

Imagine you have a dataset where each record contains a patient's age, weight, and whether they are a smoker. The goal is to analyze this dataset to answer specific questions, such as "How many patients are overweight smokers?" or "What is the count of non-smokers within a healthy weight range?"

This module isn't just an academic exercise; it's a direct application of fundamental programming concepts that are essential for building any non-trivial application on StarkNet or other ZK-Rollups. You will be required to use:

• Structs: To model real-world entities like a patient record in a clean, organized way.
• Arrays: To handle collections of data, which is the standard format for datasets.
• Iteration: To process each record in the collection systematically.
• Conditional Logic (if/else): To categorize data based on specific criteria (e.g., checking if a patient's weight is above a certain threshold).
• Variable Manipulation: To accumulate results and keep track of counts in different categories.

By completing this module, you solidify your understanding of these core components in a cohesive, practical context, preparing you for more complex challenges in decentralized application development.

Why Mastering Data Aggregation is a Superpower in Web3

In traditional web development, processing a list of a few thousand records is a trivial task. You have abundant memory and processing power, and the cost of an inefficient loop is negligible. In the world of blockchain and verifiable computation, the entire paradigm shifts. Every computation has a cost, measured in gas, and every piece of data stored on-chain consumes valuable resources.

This is where mastering data aggregation in Cairo becomes a developer's superpower. The skills you build in the Health Statistics module are directly applicable to high-stakes Web3 domains:

• DeFi Analytics: Imagine calculating the total value locked (TVL) across thousands of user positions, or aggregating trading volumes for a decentralized exchange (DEX). This requires efficient iteration and calculation, exactly what this module teaches.
• On-Chain Gaming: Game state, leaderboards, and player statistics often need to be calculated and verified on-chain. An inefficient process could make the game unplayably expensive for users.
• Decentralized Autonomous Organizations (DAOs): Tallying votes from thousands of token holders for a governance proposal is a classic data aggregation problem. The process must be verifiable, transparent, and gas-efficient.
• Verifiable Oracles: When bringing off-chain data on-chain, it often needs to be aggregated from multiple sources. For example, calculating a median price feed for an asset requires processing a collection of price points.

The bottom line is that on-chain computation is resource-constrained. Writing code that is not only correct but also performant is non-negotiable. The Health Statistics module forces you to think about efficiency from the start, building habits that will save you and your users significant costs in real-world applications.

How to Solve the Health Statistics Challenge: A Step-by-Step Guide

Let's break down the problem into manageable steps. We'll build the solution from the ground up, explaining the purpose of each piece of Cairo code. Our goal is to create a function that can process an array of patient data and return a structured report.

Step 1: Defining the Data Structure with `struct`

Before we can process data, we need a way to represent it. A single patient has multiple attributes (age, weight, smoker status). A Cairo struct is the perfect tool for bundling these related pieces of data together into a single, logical unit.

Let's define a Patient struct. We'll use a u32 for age and weight, and a bool for the smoker status. We also need to derive certain traits to make our struct usable with arrays and other language features.

use array::ArrayTrait;

#[derive(Copy, Drop)]
struct Patient {
    age: u32,
    weight: u32,
    is_smoker: bool,
}

#[derive(Copy, Drop)]
struct HealthReport {
    overweight_smokers: u32,
    healthy_weight_non_smokers: u32,
}

In this snippet, we've defined two structs. The Patient struct holds the input data for a single person. The HealthReport struct is what our function will return—it holds the aggregated counts. The #[derive(Copy, Drop)] attribute is crucial; it tells the compiler how to handle these structs in memory, allowing them to be copied and cleaned up automatically, which is often necessary when storing them in collections like an Array.

Step 2: The Core Logic - Iterating and Analyzing

Now for the heart of our program. We need a function that accepts an Array of Patient structs and returns a HealthReport. The logic will involve creating a loop that goes through each patient one by one and applies our classification rules.

Let's assume our classification rules are:

• A patient is "overweight" if their weight is greater than 100.
• A patient is "healthy weight" if their weight is 100 or less.

We want to count two groups: "overweight smokers" and "healthy weight non-smokers".

Here is the logic flow for our analysis process:

    ● Start with Array<Patient>
    │
    ▼
  ┌─────────────────────────┐
  │ Initialize Report Counters │
  │ (smokers: 0, healthy: 0)  │
  └──────────┬──────────────┘
             │
             ▼
  ┌─── Loop through each patient ───┐
  │                                  │
  │     ◆ Is patient a smoker?       │
  │    ╱          ╲                  │
  │  Yes           No                │
  │   │            │                 │
  │   ▼            ▼                 │
  │ ◆ Is weight > 100?  ◆ Is weight <= 100? │
  │╱     ╲         ╱      ╲          │
  Yes     No       Yes      No         │
  │       │        │        │          │
  ▼       ▼        ▼        ▼          │
  [Inc. Smoker] [Ignore] [Inc. Healthy] [Ignore]
  │                                  │
  └──────────┬───────────────┘
             │
             ▼
  ┌──────────────────┐
  │ Return Final Report │
  └──────────────────┘
             │
             ▼
           ● End

This diagram clearly shows the decision-making process inside our loop. For each patient, we follow a path down the tree to determine which, if any, counter to increment.

Step 3: Implementing the Function in Cairo

With our data structures and logic defined, we can write the main function. We'll initialize our HealthReport with zero counts, then use a while loop with an index to iterate through the array. This is a common and efficient pattern in Cairo.

fn generate_statistics(patients: @Array<Patient>) -> HealthReport {
    let mut report = HealthReport {
        overweight_smokers: 0,
        healthy_weight_non_smokers: 0,
    };

    let mut i = 0;
    let len = patients.len();
    while i < len {
        // Get a snapshot of the current patient
        let patient = *patients.at(i);

        // Condition 1: Overweight Smokers
        if patient.is_smoker && patient.weight > 100 {
            report.overweight_smokers += 1;
        }

        // Condition 2: Healthy Weight Non-Smokers
        if !patient.is_smoker && patient.weight <= 100 {
            report.healthy_weight_non_smokers += 1;
        }

        i += 1;
    };

    report
}

Let's break down the key lines:

• fn generate_statistics(patients: @Array<Patient>) -> HealthReport: This defines our function, which takes a snapshot (read-only reference) of an array of patients and is declared to return a HealthReport.
• let mut report = ...: We declare our report variable as mutable (mut) because we need to update its counter fields inside the loop.
• while i < len: This is our loop condition. It will run as long as our index i is less than the total number of patients.
• let patient = *patients.at(i);: This is a crucial line. patients.at(i) gets a reference to the patient at the current index. The dereference operator * creates a copy of the patient data (which is possible because we derived Copy), so we can work with it locally.
• if patient.is_smoker && patient.weight > 100: This is our compound conditional logic. We use the logical AND operator (&&) to check if both conditions are true.
• report.overweight_smokers += 1;: If the condition is met, we increment the corresponding counter in our report.
• return report;: After the loop finishes, the function implicitly returns the final state of the report variable.

Code Deep Dive: Understanding the Nuances

While the code above is functional, understanding the "why" behind certain Cairo idioms is key to becoming a proficient developer. Let's explore two important concepts at play here: immutability and data access patterns.

Immutable by Default: The Role of `mut`

One of the core safety features of Cairo (inspired by Rust) is that variables are immutable by default. This means once a value is assigned to a variable, it cannot be changed. This helps prevent a whole class of bugs common in other languages where variables are accidentally modified.

In our example, we explicitly needed to change the values of our counters and our loop index. That's why we declared them with the mut keyword:

let mut report = ...;

let mut i = 0;

Forgetting to add mut when you intend to modify a variable is a common error for beginners, but the Cairo compiler will immediately catch it and provide a helpful error message. Embracing immutability by default leads to safer, more predictable code.

Ownership and Snapshots in Loops

In Cairo, data access is carefully managed. When we pass the array to our function as patients: @Array<Patient>, the @ symbol indicates we are passing a "snapshot." This is essentially a read-only view of the array. Our function can look at the data, but it cannot modify the original array. This is another safety feature that prevents unintended side effects.

Inside the loop, the line let patient = *patients.at(i); is doing something very specific. It accesses the data at index i and, because our Patient struct has the Copy trait, it creates a full copy of that patient's data into the new patient variable. This is efficient for small structs and makes the logic simple, as we are now working with a local copy and don't have to worry about complex borrowing rules.

Here is a more detailed look at the logic for processing a single record:

    ● Read Patient Record from Array
    │  (e.g., { age: 35, weight: 110, is_smoker: true })
    │
    ▼
  ┌───────────────────────────┐
  │ Is `is_smoker` == true?   │
  └─────────────┬─────────────┘
                │
               Yes
                │
                ▼
  ┌───────────────────────────┐
  │ Is `weight` > 100?        │
  └─────────────┬─────────────┘
                │
               Yes
                │
                ▼
  ┌───────────────────────────┐
  │ Increment `overweight_smokers` │
  └───────────────────────────┘
                │
                ▼
             ● End Path for this record

This micro-flow demonstrates the sequential checks that lead to an action. If any check fails, the program simply moves on to the next patient in the array.

---

Common Pitfalls and Best Practices

When working on data processing tasks in Cairo, developers can run into a few common issues. Being aware of them ahead of time can save you hours of debugging.

Pitfall	Explanation	Best Practice / Solution
Forgetting `mut`	The compiler will throw an error if you try to reassign an immutable variable. This is most common with loop counters and accumulators.	Always declare variables you intend to change with the mut keyword. Think ahead about which variables need to be mutable.
Array Index Out of Bounds	Accessing an index that doesn't exist (e.g., i <= len instead of i < len) will cause a panic, halting program execution.	Always use a strict less-than (<) comparison with the array's length. Double-check your loop termination conditions.
Incorrect Logic in Conditionals	Mixing up && (AND) and || (OR) or misplacing a ! (NOT) can lead to silent bugs where the code runs but produces the wrong results.	Break down complex conditions into smaller parts. Write tests for each logical branch to verify your code behaves as expected.
Gas Inefficiency	For very large datasets on-chain, creating copies of data in a loop (like our *patients.at(i)) can become gas-intensive.	For performance-critical code, you might work with references (ref) instead of copies to avoid unnecessary data duplication, though this can add complexity. For this module, copying is perfectly fine.
Integer Overflow	If your counters could potentially exceed the maximum value of their type (e.g., u32::max), the program will panic.	Choose an appropriate integer type for your expected data size. For extremely large counts, you might use a u64 or even a u128.

---

The Learning Path: Your Next Steps

You now have the theory, the code, and the context to tackle the challenge. The best way to solidify this knowledge is to put it into practice. The kodikra learning path provides an interactive environment where you can write, test, and submit your own solution.

This module is your entry point into the world of practical Cairo development. Completing it will give you the confidence to move on to more advanced topics.

• Learn Health Statistics step by step - Dive in and write the code. Use the concepts from this guide to build your solution and pass all the tests.

After mastering this, you'll be well-prepared for other modules in the Cairo curriculum that explore more complex data structures like dictionaries, advanced control flow, and interactions with smart contract storage.

---

Frequently Asked Questions (FAQ)

What is a `struct` in Cairo and why is it used here?

A struct, or structure, is a custom data type that lets you group together related variables of different types into a single, named unit. We use it here to create a Patient type, which makes the code much more readable and organized than passing around separate variables for age, weight, and smoker status.

How does iteration work on an `Array` in Cairo?

While newer versions of Cairo are introducing more advanced iterators, the fundamental and most common way to iterate is using a while loop with a manual index counter. You get the array's length, initialize an index to 0, and loop until the index reaches the length, incrementing it each time.

Couldn't I use a `LegacyMap` (Dictionary) for this problem?

A LegacyMap (or dictionary) is used for key-value storage. It would not be a good fit for this specific problem because our input is an unordered list of records, not data that needs to be looked up by a unique key. An Array is the natural choice for representing a list or sequence of items.

What are the most common mistakes when starting this module?

The most frequent errors are syntax-related: forgetting a semicolon, missing the mut keyword for counters, or using incorrect syntax for accessing array elements (e.g., patients[i] which is not valid in Cairo, instead of *patients.at(i)). The second most common issue is flawed conditional logic.

How does this relate to gas optimization on StarkNet?

Every operation inside the loop (reading data, comparison, addition) consumes gas. While this example is small, if the array contained millions of records, an inefficient loop could be prohibitively expensive. This module teaches the foundational pattern for data processing, which you can later optimize by, for example, using more gas-efficient data types or algorithms.

Is Cairo a good language for heavy data analysis?

Cairo's primary purpose is to create provable programs for verifiable computation, not for general-purpose "big data" analysis like Python or R. However, a significant number of on-chain applications require some form of data analysis and aggregation (like DeFi analytics or DAO voting), making the skills taught in this module essential for any StarkNet developer.

---

Conclusion: From Data to Verifiable Insights

You've just journeyed through one of the most fundamental tasks in programming: turning raw data into meaningful information. The Health Statistics module is far more than an exercise in syntax; it's a microcosm of the challenges and rewards of building on the decentralized web. You've learned how to structure data with structs, handle collections with Arrays, and implement custom logic with loops and conditionals—all within the robust, safety-first framework of Cairo.

These skills are your building blocks for creating the next generation of applications on StarkNet. Whether you're calculating financial metrics, tallying votes, or creating complex game mechanics, the core pattern of iterating, classifying, and aggregating data will be at the center of your work. By mastering this module, you've taken a significant step towards becoming a capable and confident Cairo developer.

Technology Disclaimer: The Cairo language and its ecosystem are under continuous development. The code snippets and concepts in this article are based on Cairo 1.0 and later syntax. Always refer to the official Cairo and StarkNet documentation for the most current information.

Back to the complete Cairo Guide

---

Published by Kodikra — Your trusted Cairo learning resource.