DEV Community: Francesco Ciulla

Rust CRUD Rest API, using Axum, sqlx, Postgres, Docker and Docker Compose

Francesco Ciulla — Tue, 16 Dec 2025 13:49:16 +0000

Let's create a CRUD Rest API in Rust, using the following:

Axum (Rust web framework)
sqlx (ORM)
Postgres (database)
Docker (containerization)
Docker Compose (to run the application and the database in containers)

If you prefer a video version:

All the code is available in the GitHub repository (link in the video description):

🏁 Intro

Here is a schema of the architecture of the application we are going to create:

We will create 5 endpoints for basic CRUD operations:

Create
Read all
Read one
Update
Delete

We will also create a simple endpoint to test if the server is running.

Here are the steps we are going through:

Create a compose.yml file and ru the Postgres instance
Create an Axum application using sqlx as an ORM
Dockerize the Axum application
Run the Axum application using docker compose
Test the application

We will go with a step-by-step guide, so you can follow along.

🛑 Prerequisites

Before starting, make sure you have the following installed on your machine:

Docker
Rust and Cargo

🏁 Project initialization

Let's iitialize the project:

cargo new axumlive

This will create a new folder called axumlive with the following structure:

axumlive
│   Cargo.toml
└───src
    │   main.rs

Run the Postgres container

Let's run the Postgres container first, so we have the database ready when we will run the Axum application.

To do that, create a file called compose.yml in the root of the project (axumlive folder) with the following content:

  db:
    image: postgres:15
    container_name: db
    ports:
      - "5432:5432"
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
      POSTGRES_DB: simple_api
    volumes:
      - pg_data:/var/lib/postgresql/data

volumes:
  pg_data:

Now, to run the Postgres container, type:

docker compose up -d db

This will run the Postgres container in detached mode (in the background).

If you see something like this, it means that the container is running:

Now, to check if the container is running, type:

docker ps -a

If everything is ok, you should see something like this:

Now before we write our Axum application, let's step inside the Postgres container:

docker exec -it db psql -U user -d simple_api

This will open the Postgres shell.

You should see something like this:

Now type:

\dt

And you should see "didn't find any relations" because the database is empty.

This is normal but let's keep this terminal open somewhere. We will use it later to check if the tables are created correctly.

📦 Add dependencies and the Sql migrations

Let's add the dependencies we need to the Cargo.toml file.

...
[dependencies]
axum = "0.8"
tokio = { version = "1", features = ["macros", "rt-multi-thread", "net"] }
sqlx = { version = "0.8", features = ["runtime-tokio-rustls", "postgres", "macros"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"

Since we want a convenient way to create the tables in the database, we will use sqlx migrations. This allows us to create the table the first time we run the application. This is also convenient in case someone else wants to run the application, they just have to run the migrations and the tables will be created automatically.

Now, let's create a folder called migrations in the root of the project (axumlive folder) and inside it create a file called 0001_users_table.sql with the following content:

CREATE TABLE IF NOT EXISTS users (
    id SERIAL PRIMARY KEY,
    name TEXT NOT NULL,
    email TEXT NOT NULL UNIQUE
);

We are now ready to write the Axum application.

📦 Add The Dependncies

Open the Cargo.toml file and add the following dependencies:

[dependencies]
axum = "0.8"
tokio = { version = "1", features = ["macros", "rt-multi-thread", "net"] }
sqlx = { version = "0.8", features = ["runtime-tokio-rustls", "postgres", "macros"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"

🦀 Create the Axum backend

Let's open the main.rs file and populate it with the following code:

use axum::{ extract::{ Path, State }, http::StatusCode, routing::{ get, post }, Json, Router };
use serde::{ Deserialize, Serialize };
use sqlx::{ postgres::PgPoolOptions, FromRow, PgPool };
use std::env;

#[derive(Deserialize)]
struct UserPayload {
    name: String,
    email: String,
}

#[derive(Serialize, FromRow)]
struct User {
    id: i32,
    name: String,
    email: String,
}

#[tokio::main]
async fn main() {
    let db_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    let pool = PgPoolOptions::new().connect(&db_url).await.expect("Failed to connect to DB");
    sqlx::migrate!().run(&pool).await.expect("Migrations failed");

    let app = Router::new()
        .route("/", get(root))
        .route("/users", post(create_user).get(list_users))
        .route("/users/{id}", get(get_user).put(update_user).delete(delete_user))
        .with_state(pool);

    let listener = tokio::net::TcpListener::bind("0.0.0.0:8000").await.unwrap();
    println!("🚀 Server running on port 8000");
    axum::serve(listener, app).await.unwrap();
}

//Endpoint Handlers
//test endpoint
async fn root() -> &'static str {
    "Welcome to the User Management API!"
}

//GET ALL
async fn list_users(State(pool): State<PgPool>) -> Result<Json<Vec<User>>, StatusCode> {
    sqlx::query_as::<_, User>("SELECT * FROM users")
        .fetch_all(&pool).await
        .map(Json)
        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)
}

//CREATE USER
async fn create_user(
    State(pool): State<PgPool>,
    Json(payload): Json<UserPayload>
    ) -> Result<(StatusCode, Json<User>), StatusCode> {
    sqlx::query_as::<_, User>("INSERT INTO users (name, email) VALUES ($1, $2) RETURNING *")
        .bind(payload.name)
        .bind(payload.email)
        .fetch_one(&pool).await
        .map(|u| (StatusCode::CREATED, Json(u)))
        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)
}

//GET USER BY ID
async fn get_user(
    State(pool): State<PgPool>,
    Path(id): Path<i32>
    ) -> Result<Json<User>, StatusCode> {
    sqlx::query_as::<_, User>("SELECT * FROM users WHERE id = $1")
        .bind(id)
        .fetch_one(&pool).await
        .map(Json)
        .map_err(|_| StatusCode::NOT_FOUND)
}

//UPDATE USER
async fn update_user(
    State(pool): State<PgPool>,
    Path(id): Path<i32>,
    Json(payload): Json<UserPayload>
    ) -> Result<Json<User>, StatusCode> {
    sqlx::query_as::<_, User>("UPDATE users SET name = $1, email = $2 WHERE id = $3 RETURNING *")
        .bind(payload.name)
        .bind(payload.email)
        .bind(id)
        .fetch_one(&pool).await
        .map(Json)
        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)
}

//DELETE USER
async fn delete_user(
    State(pool): State<PgPool>,
    Path(id): Path<i32>
) -> Result<StatusCode, StatusCode> {
    let result = sqlx
        ::query("DELETE FROM users WHERE id = $1")
        .bind(id)
        .execute(&pool).await
        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;

    if result.rows_affected() == 0 {
        Err(StatusCode::NOT_FOUND)
    } else {
        Ok(StatusCode::NO_CONTENT)
    }
}

Explanation:

We define the data structures for the user payload and the user model using Serde for serialization and deserialization.
We set up the database connection using sqlx and run the migrations to create the users table
We define the Axum routes for the CRUD operations and associate them with their respective handler functions
Each handler function interacts with the database using sqlx to perform the required operations and returns appropriate HTTP responses.
Finally, we start the Axum server on port 8000. ___ ## 🐳 Dockerize the Axum application

It's time to Dockerize the Rust application. To do this, first let's create a .dockerignore file in the root of the project (axumlive folder) with the following content:

target
.git

This will prevent Docker from copying the target folder and the .git folder into the Docker image, which are not needed.

In the root folder of the project (axumlive), create a file called Dockerfile
This one will be a multi-stage Dockerfile, to keep the final image as small as possible.

Let's populate the Dockerfile

Dockerfile:

#stage 1
FROM rust:1.91 as builder
WORKDIR /app
COPY . .
RUN cargo build --release


#stage 2
FROM debian:bookworm-slim
WORKDIR /app
COPY --from=builder /app/target/release/axumlive .
EXPOSE 8000
CMD ["./axumlive"]

🐳🐳Docker compose

Since now we defined the Axum application and we dockerized it, it's time to add this service to the compose.yml file, so we can run both the Axum application and the Postgres database with a single command.

Populate the docker-compose.yml file:

services:
  app:
    container_name: simple_axum
    build: .
    ports:
      - "8000:8000"
    environment:
      DATABASE_URL: postgres://user:password@db:5432/simple_api
  db:
    image: postgres:15
    container_name: db
    ports:
      - "5432:5432"
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
      POSTGRES_DB: simple_api
    volumes:
      - pg_data:/var/lib/postgresql/data

volumes:
  pg_data:

We defined a new service called "app" which is the Axum application. We set the build context to the current directory (.) and we map the port 8000 of the container to the port 8000 of the host machine.

👟 Build and Run the Axum appliation

Now let's build so we can run the Axum application.

Let's type

docker compose build

And you should see something like this:

This should BUILD the app image, with the name defined in the "image" value, in this case, ""simple_axum".

You can also see all the steps docker did to build the image, layer by layer. You might recognize some of them, because we defined them in the Dockerfile.

Now let's run the app service:

docker compose up -d app

This will run the app service in detached mode (in the background).

Let's check if both the containrs are running:

docker ps -a

Important step: is you go back to the psql terminal where we stepped into the Postgres container, and type:

\dt

you should now see the users table created by the migration:

Of course, this talbe is currenlty empty, but at least we know that the migration ran successfully when the Axum application started.

🔍 Test the application

Now let's test our application.

The first step is to visit http://localhost:8000/ in your browser:

You can tet it in different ways. In this specific case, I will use a VS Code extension called REST Client, but you can use Postman, curl or any other tool you prefer.

You can test the application in the way you prefer, but for convenience I will add a file you can copy paste in your application at the root level, called request.hhtp, with all the requests we need to test the applicationL

// requests.http
@baseUrl = http://localhost:8000

### 1. Test Root Endpoint (Health Check)
GET {{baseUrl}}/

### 2. Get All Users (Should be empty initially)
GET {{baseUrl}}/users

### 3. Create User 1
POST {{baseUrl}}/users
Content-Type: application/json

{
    "name": "Alice Smith",
    "email": "alice@example.com"
}

### 4. Create User 2
POST {{baseUrl}}/users
Content-Type: application/json

{
    "name": "Bob Jones",
    "email": "bob@example.com"
}

### 5. Create User 3
POST {{baseUrl}}/users
Content-Type: application/json

{
    "name": "Charlie Day",
    "email": "charlie@example.com"
}

### 6. Get All Users (Should see 3 users now)
GET {{baseUrl}}/users

### 7. Get Single User (Assuming ID 1 exists)
GET {{baseUrl}}/users/1

### 8. Get User that does not exist (Test 404)
GET {{baseUrl}}/users/9999

### 9. Update User 2
# Note: Ensure your backend handles PUT or PATCH for updates
PUT {{baseUrl}}/users/2
Content-Type: application/json

{
    "name": "Bob James",
    "email": "bobjames@example.com"
}

### 10. Get All Users (Verify Update)
GET {{baseUrl}}/users

### 11. Delete User 2
DELETE {{baseUrl}}/users/3

### 12. Get All Users (Final check - Bob should be gone)
GET {{baseUrl}}/users

You can test the example Endoiunt by runnig the first request in the file
, which is a GET request to localhost:8000/

📝 Create a user

Now let's create a user, making a POST request to localhost:8000/users with the body below as a request body:

Let's create another one:

One more:

📝 Get all users

Now, let's make a GET request to localhost:8000/users to get all the users:

We just created 3 users.

From the browser, we can see:

If we go back to the psql terminal where we stepped into the Postgres container, and type:

SELECT * FROM users;

we should see the 3 users we just created:

📝 Get a specific user

If you want to get a specific user, you can make a GET request to localhost:4000/users/<user_id>.

For example, to get the user with id 1, you can make a GET request to localhost:8000/users/1

If we try to get a user that does not exist, for example the user with id 9999, we should get a 404 error:

📝 Update a user

If you want to update a user, you can make a PUT request to localhost:8000/users/<user_id>.

For example, to update the user with id 2, you can make a PUT request to localhost:8000/users/2 with the body below as a request body:

📝 Delete a user

To delete a user, you can make a DELETE request to localhost:4000/users/<user_id>.

For Example, to delete the user with id 3, you can make a DELETE request to localhost:8000/users/3

To check if the user has been deleted, you can make a GET request to localhost:8000/users or check directly in the browser:

As you can see the user with id 3 is not there anymore.

🏁 Conclusion

We made it! We have built a CRUD rest API in Rust using Axum, sqlx, and Postgres, and we dockerized the application.

This is just an example, but you can use this as a starting point to build your own application.

If you prefer a video version:

All the code is available in the GitHub repository (link in the video description): https://youtu.be/cJyl9e2oqHY

That's all.

If you have any question, drop a comment below.

Francesco

Redox OS: Is the Future of Operating Systems Written in Rust?

Francesco Ciulla — Thu, 11 Dec 2025 04:11:01 +0000

Hi! Have you ever wondered what an operating system would look like if it were built today, prioritizing memory safety and modern design patterns from the ground up? Meet Redox OS.

What is Redox?

Redox is a Unix-like operating system written in Rust. Unlike the monolithic kernels of Linux or Windows, Redox utilizes a microkernel design. This means the core kernel is tiny, and most services (like drivers and filesystems) run in userspace.

The result? A system that is incredibly stable and secure. Because it is written in Rust, it effectively eliminates entire classes of bugs and security vulnerabilities related to memory management that have plagued older OSs for decades.

A Chat with the Creator

I recently had the incredible opportunity to attend RustConf, where I had the chance to catch up with Jeremy Soller, the creator of Redox OS.

We chatted about the challenges of building an OS from scratch, the benefits of the microkernel architecture, and where the project is heading next. It was fascinating to hear directly from the source how Rust is enabling a new era of system development.

Let me know what you think!
Francesco

AI vs. Machine Learning vs. Deep Learning

Francesco Ciulla — Thu, 04 Dec 2025 18:36:55 +0000

Read time: ~1 min

You hear the terms Artificial Intelligence, Machine Learning, and Deep Learning every day. People often use them interchangeably, but they are not the same thing. Using them incorrectly can make it sound like you don't know what you're talking about.

If you prefer a video version, you can watch it here:

To fix this, let's visualize the concepts using a Russian nesting doll.

1. The Outer Shell: Artificial Intelligence (AI)

Imagine the biggest doll. This is AI.
It is the broad umbrella term for any technique that enables computers to mimic human intelligence. This includes everything from the super-smart robots in sci-fi movies to the ghosts in Pac-Man.

If you write a program with a thousand if/else statements to play chess, that is technically AI. It mimics intelligence, but it doesn't strictly "learn."

2. The Middle Doll: Machine Learning (ML)

Open the big doll, and inside is Machine Learning.
This is where things get interesting. In traditional AI, you explicitly tell the computer rules; in Machine Learning, you give it data.

If you show the machine 10,000 pictures of cats and dogs, it figures out the rules itself using statistics. It learns from experience. This technology is what powers your Netflix recommendations and email spam filters.

3. The Smallest Doll: Deep Learning (DL)

Inside the middle doll is the smallest, most complex one: Deep Learning.
This is a specialized subset of Machine Learning. While ML relies on statistics, Deep Learning uses neural networks—structures inspired by the human brain.

It uses layers of artificial neurons to process massive amounts of complex data. This requires huge computing power but achieves results that traditional ML never could, powering self-driving cars, facial recognition, and ChatGPT.

The Summary

Here is the hierarchy: Deep Learning is a type of Machine Learning, which is a type of AI. Not all AI learns, but all Deep Learning is AI.

Now you know the difference. Next time someone tries to sell you an "AI toothbrush," you can ask them if it uses a neural network or just a simple if/else statement.

If you prefer a video version, you can watch it here:

Rust Hello World: The Hard and the Smart Way

Francesco Ciulla — Wed, 26 Nov 2025 05:48:52 +0000

How do we make a Hello World in Rust??

If you prefer watching over reading, you can watch the video version of this bootcamp segment right here:

The Prerequisites

The first thing you should do is install Rust. You should end up on a page that guides you through using rustup, which is an excellent tool for managing Rust versions.

To verify your installation, type rustc --version in your terminal.

Rust is a compiled programming language. rustc is the compiler, and cargo is the package manager. If you have both of these, you are good to go.

The "Hard Way" (Manual Compilation) 🔨

We will start with a very simple "Hello, World!" because this step is very important to understand what happens behind the scenes.

This approach uses rustc directly. This is something you usually don't see in tutorials, but it helps to understand what automated tools do for us later.

Create a new folder and construct a file named main.rs (.rs is the extension for Rust files).
Open it in your favorite IDE (VS Code, RustRover, etc.) and add the code:
```
fn main() {
    println!("Hello, world!");
}
```
How do you run this? There isn't a play button. You need to compile it.
Run this command in your terminal:
```
rustc main.rs
```
This compiles the code and creates an executable in your folder (e.g., just main on Linux/macOS or main.exe on Windows).
Run the executable:
```
./main
# Output: Hello, world!
```

Why is this the "Hard Way"?
If you make a change to the file—for example, adding a crab emoji 🦀 to the string—and save it, running ./main again won't show the change. You must manually run rustc main.rs again to recompile the changes every single time. This is obviously not ideal for real development.

I've done this just because I want you to understand what cargo does behind the scenes.

The "Smart Way" (Cargo) 🚀

Usually, you will initialize a Rust project using Cargo. Cargo is basically the npm of the Rust world.

Let's initialize a new project the standard way:

Run the following command to create a new project:
```
cargo new rust_live_one
```
Cargo will create the directory structure for you. It creates a src folder containing main.rs, sets up a git repository, and creates a Cargo.toml file (which is similar to package.json in JS or requirements.txt in Python).
To run this project, you don't use rustc. You use:
```
cargo run
```

If you change your code and run cargo run again, Cargo realizes the code has changed and recompiles the necessary files automatically before running it. Thank you, Cargo!

🦀 Pro Tip: Quiet Mode

By default, Cargo prints outputs like "Compiling..." and "Finished..." before showing your program's output.

If you want the exact same clean output we had with the manual method, use the quiet flag:

cargo -q run

Here is a handy cheat sheet summarizing the setup process (click the image to watch the video!):

If you prefer watching over reading, you can watch the video version of this bootcamp segment right here:

Rust vs. Your Next JavaScript Framework: Which Should You Learn?

Francesco Ciulla — Fri, 12 Sep 2025 15:02:30 +0000

Rust vs. Your Next JavaScript Framework: Which Should You Learn?

Hey everyone! Today, we're tackling a big question for developers: Should you dive into the world of Rust, or is it smarter to just pick up the next popular JavaScript framework? Let's break it down.

If you prefer a video version

For nine consecutive years, Rust has been voted the "most admired" programming language in developer surveys. It's like a rock band that keeps topping the charts, but its fan base is system engineers and those who love a good compiler error message. Major companies such as Microsoft, Google, and AWS are adopting it, especially for projects where tricky C++ memory bugs just won't cut it at 3:00 a.m.

But is it worth your time? Let's find out.

What Exactly Is Rust? 🤔

Rust is a systems programming language designed for three main priorities: speed, safety, and concurrency.

Think of it this way: Rust is like C++ after it went to therapy, worked through its trust issues, and came back with a very strict rule book about relationships (we call them ownership and borrowing). This rule book aims to prevent common bugs and crashes before your code even runs.

You can use Rust for a wide range of exciting projects, including:

Operating systems
WebAssembly (Wasm) applications
High-performance backend APIs
Blockchain projects
Command-line tools that make you feel like a hacker from the future

The Good Stuff: Why You'll Love Rust ❤️

Let's explore why you'd want to add Rust to your skillset.

Blazing Performance: Rust operates at speeds nearly identical to C and C++, making languages like Python look slow in comparison. Your applications will be highly efficient.

Memory Safety Without a Garbage Collector: Rust guarantees memory safety without needing a garbage collector running in the background. That means no dangling pointers ruining your day and no performance hits from a garbage collector pausing your program.

Fearless Concurrency: Writing multi-threaded code can be challenging. Rust's ownership rules eliminate many common concurrency bugs at compile time, so you can write parallel code with confidence.

Amazing Ecosystem and Tooling: Cargo, Rust's package manager and build tool, is a pleasure to work with. It's like npm, but it doesn't fall apart when you look at it the wrong way. The compiler (rustc) and tools like Clippy are also fantastic—they don't just point out your mistakes; they often give you helpful advice and suggest the exact fix.

The "You Might Regret This" Part: The Challenges 🥵
Before you update your LinkedIn profile, let's talk about the reality. Rust isn't all sunshine and rainbows.

The Learning Curve is a Cliff: Rust can be tough at first. Concepts like ownership, borrowing, and lifetimes aren't just new; they test your patience. The compiler is notoriously strict.

Slow Compile Times: Be prepared to wait. Rust compiles slower than your Wi-Fi on an airplane. You might either get used to it or develop a new hobby, like making tea between builds.

Growing Ecosystem: While Rust's ecosystem is expanding rapidly, you won't always find a ready-made library (crate) for every problem, unlike the large ecosystems of Python or JavaScript.

Who Should Learn Rust?

So, is Rust for you?

✅ You should learn Rust if...
You love control: If you're into understanding exactly what your code does at a low level, Rust is perfect.

You care about safety and reliability: If you've ever lost production data to a memory leak, Rust will feel like a warm, safe hug.

You want in-demand skills for the future: Top tech companies are hiring Rust developers now, and demand will only grow.

❌ You should probably skip Rust (for now) if...
Just want to build an MVP quickly: If your goal is to ship a project by next weekend, stick with Python, JavaScript, or other options. Rust emphasizes correctness over speed of development.

You dislike strict rules: Rust is a rulebook in programming language form. Breaking a rule will invite the compiler to roast you more than a Stack Overflow comment section.

You're allergic to semicolons: Sorry, Rust uses plenty of them.

The Verdict: Is Rust Here to Stay?
Absolutely. Rust is no longer just hype; it's becoming part of modern infrastructure. It's now supported in the Linux kernel, Microsoft is rewriting parts of Windows with it, and even modern JavaScript tools like Deno and Bun are built with Rust.

So, should you learn it?

If you're looking for a challenge, want to build high-performance software, and are interested in a language that can significantly enhance your development skills, then yes, learn Rust.

If you need to get something working by Friday, maybe hold off for now.

But if you do decide to dive in, remember: the compiler isn't your enemy. It's a very strict friend (or an annoying grandma) who genuinely wants you to succeed.

If you prefer a video version

Open AI Releases Open Models

Francesco Ciulla — Wed, 06 Aug 2025 04:25:57 +0000

Open AI is now finally Open AI.

OpenAI has just released two new advanced open-weight models, gpt-oss-120b and gpt-oss-20b.

These models are designed for high-end reasoning tasks and offer flexibility for customization and deployment.

Sam Altman is very bullish about this.

What is an Open-Weight Model?

An open-weight model is an AI, often an LLM, with publicly shared parameters or "weights" learned during training.

Sharing them allows users to easily run, explore, and customize the model on their own hardware, unlike closed models, which are only accessible through an API with proprietary weights.

Two Model Sizes

gpt-oss-120b: Powerful, large model with 120 billion parameters, specially optimized for smooth performance in data centers and on high-end desktops and laptops.

gpt-oss-20b: Versatile, medium-sized model with 20 billion parameters designed to be accessible to many, efficiently running on most modern desktops and laptops.

To try out these models, you can visit: https://gpt-oss.com/

Apache 2.0 License

Both models are provided under the Apache 2.0 license, so you can easily use, modify, and share them. This opens up exciting possibilities for us to create, experiment, personalize, and launch commercial applications without worrying about copyleft requirements or patent issues.

GitHub repository: https://github.com/openai/gpt-oss.

Designed for Agentic Tasks

The claim is that these models are really good at handling complex, multi-step tasks easily and that they shine in following instructions and make great use of their impressive tools, such as web searches and Python coding, to help solve problems more effectively.

Deep Customization & Fine-Tuning

Users have granular control over the models' performance. The reasoning effort can be adjusted to low, medium, or high, balancing performance with resource consumption.

The models support full-parameter fine-tuning, allowing developers to adapt them precisely to specific use cases and achieve optimal results.

This sounds great, but of course, it needs to be tested.

Model Performance

The models' performance seems promising. 📈

Benchmark	gpt-oss-120b	gpt-oss-20b	OpenAI o3	OpenAI o4-mini
Reasoning & Knowledge
MMLU	90.0	85.3	93.4	93.0
GPQA Diamond	80.1	71.5	83.3	81.4
Humanity's Last Exam	19.0	17.3	24.9	17.7
Competition math
AIME 2024	96.6	96.0	95.2	98.7
AIME 2025	97.9	98.7	98.4	99.5

Research blog: https://openai.com/index/introducing-gpt-oss/

Chain-of-Thought (CoT) Access

OpenAI now provides complete access to the model's reasoning process.

Finally, some transparency. That's great for easier debugging, understanding how the model arrived at an output, and building higher trust in its results.

Official Blog Post: https://openai.com/index/introducing-gpt-oss/

Conclusion

I hope this overview of OpenAI's new open-weight reasoning models has been helpful. These models represent a significant step in making advanced AI more accessible and customizable for developers and researchers.

If you have any questions or need further information, comment below or contact me directly.

You can find me here: Francesco Ciulla

Should you join a community to learn Rust?

Francesco Ciulla — Tue, 13 May 2025 08:06:56 +0000

Short answer: yes

Over the past 5 years, I've learned a lot about communities.

I've made many mistakes: I could probably create a 'Community Mistakes 101' crash course! Unfortunately, they didn't teach that in high school, which would have been useful.

I learned that a community absolutely must have a specific goal. I also learned that while having an open community is good at the beginning, it becomes nearly impossible to handle and moderate long-term unless you dedicate an insane amount of time to it (trust me, I tried) or you are a bored millionaire lying on the couch all day (which is not my case).

Regarding promotion, I've made the mistake in the past of overpromoting communities I created, simply because I was overjoyed about the new adventure. I now think this approach is wrong. it's better if people discover the community on their own.

But now I really feel I am ready to do it right.

So, why am I writing this? The reason is simple: I've just a new community, and I've decided to use Twitter (sorry, X) for it.

The goal is to introduce curious developers to the Rust programming language and help them understand as much as possible.

Joining this community is free, just request to join. The link is in my profile, but if you're lazy and want to be invited, just reply below.

For now, I am not accepting moderators, but moderators might be chosen from among the active members in the future.

Let's Crush it !!!🔥

Should you learn Rust as your next programming language?

Francesco Ciulla — Fri, 09 May 2025 07:29:53 +0000

Hi, I want to focus on why you might be interested in learning Rust in this short article.

If you're reading this, you may already be interested in learning Rust. However, if not, I understand you. I am also very skeptical about learning new technologies. But I am here to try to change your mind.

Here are some reasons to consider it:

Performance: The main reason Rust has become popular is that it is designed to be fast and efficient. This makes it an excellent choice for performance-critical applications. It can often match (or exceed) the performance of C and C++ while providing additional safety features. I believe it strikes a good balance between performance and safety.
Memory Safety: Rust is designed to be memory-safe. This helps avoid common programming errors like null pointer dereferences and buffer overflows. Rust achieves this through its ownership system, which enforces strict rules about how memory is accessed and shared. This is a valuable feature for developers who want to write safe and reliable code without worrying about low-level memory management!
Concurrency: Writing concurrent code is usually a nightmare; however, Rust simplifies creating concurrent programs. Its strong type system and ownership model help prevent data races.
Helpful (and annoying) Compiler & Tooling: Rust's compiler is well-known for being very helpful. It does not just report random errors (I see you Java), it often explains them thoroughly and suggests how to fix your code. I like to compare it to that old annoying grandma who wants the best for you. You know she's annoying, but she is right. Plus, Rust comes with a fantastic tool called 'Cargo' that makes it easy to manage your project's dependencies and build your programs, simplifying the development process.

Are you not convinced yet? Well, I kept the best shot as the last one:

Rust has been voted the most-admired programming language in the latest Stack Overflow survey. Do you want to base your future learning choices on what you read on Twitter, what a tech influencer says, or real data?

If you are interested in learning Rust, I just published a 3.5-hour video on YouTube; it's free and might help you understand the core concepts of the language. Good luck!

Find me here: https://francescociulla.com

Actix Web - The Rust Framework for Web Development - Hello World

Francesco Ciulla — Tue, 05 Nov 2024 14:19:00 +0000

Hi! Francesco here.

Today, we will look at Actix, a high-performance framework for building web applications in Rust.

Actix Web site: https://actix.rs/

Whether you’re just starting with Rust or are an experienced developer exploring web capabilities, Actix offers a great way to dive into web development in Rust.

Known for its speed and efficiency, Actix consistently ranks among the fastest web frameworks, leveraging asynchronous execution by default to handle many requests concurrently. This makes it well-suited for applications requiring responsiveness under load.

A great plus for JavaScript Developers is that Actix looks similar to Express, so if you are familiar with Express, you will find Actix easy to learn.

In this article, we’ll build a simple "Hello World" web app with Actix, featuring three routes. This will give us a quick overview of the syntax and allow us to see if Actix might be a good fit for our projects.

If you prefer a Video version:

Setting Up the Project

First, let’s create a new Rust project and set up our dependencies.

Create the Project:
```
cargo new actix_hello_world
```
Add Actix Dependency:
Open Cargo.toml and add the actix-web dependency:
```
[dependencies]
actix-web = "4"
```

You project structure should look like this:

Writing the Code

Next, open main.rs and start building our application. Here’s the complete code:

use actix_web::{get, post, web, App, HttpServer, Responder, HttpResponse};

#[get("/")]
async fn index() -> impl Responder {
    HttpResponse::Ok().body("Hello world!")
}

#[post("/echo")]
async fn echo(req_body: String) -> impl Responder {
    HttpResponse::Ok().body(req_body)
}

async fn manual_hello() -> impl Responder {
    HttpResponse::Ok().body("Hey there!")
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .service(index)
            .service(echo)
            .route("/hey", web::get().to(manual_hello))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Code Walkthrough

Let’s break down what each part of this code does:

We define our routes using Actix’s #[get("/")] and #[post("/echo")] attributes.
Each route maps to an asynchronous function.
The index function responds with "Hello world!" when accessed at the root (/) via a GET request (we will test it soon).
The echo function allows us to send a POST request to /echo. It returns the request body as the response, a simple echo server implementation.
The manual_hello function is another way to define a route. Instead of an attribute, we add it directly in the App setup using .route("/hey", web::get().to(manual_hello)).
The main function is where our server is created and configured.
Using HttpServer::new, we create an instance of App with our defined routes.
We then bind it to 127.0.0.1 on port 8080 and run it asynchronously.

Running and Testing the Application

Now, let’s test our Actix app (This might take a while the first time you run it):

cargo run

Testing the Routes

Test GET Requests:

Open a browser and navigate to http://127.0.0.1:8080/, and you should see "Hello world!".

For the route /hey, go to http://127.0.0.1:8080/hey, and you’ll get "Hey there!".

Test POST Requests:

For the POST /echo route, use a tool like Postman to send a POST request to http://127.0.0.1:8080/echo with a body.

For example, if you send:

 {
  "test": 123
 }

you’ll receive the same response body back (It work with a simple String, too).

Exploring More with Actix

What's my opinion about Actix? Actix’s syntax is concise, and it provides a great introduction to web programming with Rust. As we’ve seen, we can create an app with multiple routes in only a few lines of code.

Also, Actix’s documentation is extensive and easy to follow, which is always a positive sign for any project.

https://actix.rs/

The Actix GitHub repository has almost 30,000 stars, showing its popularity and active community.

I hope this was helpful, feel free to leave a comment if you have any questions or suggestions.

If you prefer a Video version:

Find me here: Francesco

All the Rust Features

Francesco Ciulla — Fri, 01 Nov 2024 14:48:00 +0000

In this article, we’ll explore all (or nearly all) of the key features that make the Rust programming language unique.

If you want to understand what sets Rust apart, dive into each feature and see how it helps make Rust an efficient, safe, and powerful language.

Fun fact: Rust’s name wasn’t inspired by iron oxidation but by a resilient fungus that thrives in extreme conditions!

Video Version

You can find me here: https://francescociulla.com

1. Memory Safety without Garbage Collection

Rust’s memory management is one of its standout features. Unlike languages that rely on a garbage collector, Rust ensures memory safety at compile time. This means there’s no runtime cost for managing memory. Instead, Rust uses a powerful system of ownership and borrowing that checks for potential issues before your program even runs.

Example

fn main() {
    let data = String::from("Hello, Rust!");
    println!("{}", data);
} // `data` is dropped here automatically, freeing memory

Rust's compiler guarantees that memory is freed without a garbage collector, resulting in more efficient memory usage.

2. Ownership System

The ownership model is fundamental to Rust’s safety. Each piece of data in Rust has a single owner, and when the owner goes out of scope, the data is automatically cleaned up. This prevents issues like dangling pointers and memory leaks.

Example

fn main() {
    let s1 = String::from("Hello");
    let s2 = s1; // `s1` is moved to `s2` and is no longer accessible
    println!("{}", s2);
}

In Rust, once data is "moved," the original variable is no longer valid, ensuring no double frees or memory leaks.

3. Borrowing and References

When you need multiple parts of your program to access the same data without transferring ownership, borrowing allows this. Rust’s references let you share data safely and lifetimes ensure that borrowed data doesn’t outlive its owner.

Example

fn main() {
    let s = String::from("Hello");
    print_length(&s);
}

fn print_length(s: &String) {
    println!("Length: {}", s.len());
} // `s` is borrowed, so ownership isn’t transferred

Borrowing keeps your program safe by controlling who can access what, preventing bugs and runtime errors.

4. Pattern Matching and Enums

Rust’s pattern matching and enums provide a powerful way to write clear, exhaustive logic that handles all possible cases. This is especially useful in error handling, where enums like Result and Option allow you to handle outcomes explicitly.

Example

enum Direction {
    North,
    South,
    East,
    West,
}

fn move_character(dir: Direction) {
    match dir {
        Direction::North => println!("Moving North"),
        Direction::South => println!("Moving South"),
        Direction::East => println!("Moving East"),
        Direction::West => println!("Moving West"),
    }
}

This ensures that every possible case is handled, making your code safe and predictable.

5. Error Handling with Result and Option

Rust avoids exceptions by making error handling a first-class citizen through Result and Option. These enums enforce safe and predictable handling, so you always consider both successful and error scenarios.

Example

fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err(String::from("Cannot divide by zero"))
    } else {
        Ok(a / b)
    }
}

With Result, the caller must handle both the happy path (Ok) and the potential error (Err), promoting robust error handling.

6. Type Inference

Although Rust is a statically typed language, you don’t need to specify types everywhere. Rust’s type inference system is smart, allowing for clean and readable code without sacrificing safety.

Example

fn main() {
    let x = 10; // Rust infers `x` as an `i32`
    let y = 20.5; // Rust infers `y` as an `f64`
    println!("x: {}, y: {}", x, y);
}
Rust’s type inference provides both flexibility and clarity.

7. Traits and Trait Objects

Rust doesn’t use traditional inheritance. Instead, it has traits to define shared behavior, enabling polymorphism without complex inheritance chains. Trait objects, like dyn Trait, provide dynamic dispatch for flexibility.

Example

trait Greet {
    fn say_hello(&self);
}

struct Person;
impl Greet for Person {
    fn say_hello(&self) {
        println!("Hello!");
    }
}

fn greet(g: &dyn Greet) {
    g.say_hello();
}

fn main() {
    let p = Person;
    greet(&p);
}

Traits allow shared behavior without needing inheritance, making Rust’s approach flexible and safe.

8. Concurrency without Data Races

Rust’s concurrency model prevents data races. By enforcing Send and Sync traits, Rust enables safe concurrency, letting you write highly concurrent code without bugs from unexpected data races.

Example

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        println!("Hello from a thread!");
    });

    handle.join().unwrap();
}

Rust’s compiler guarantees thread safety, making concurrent programming safer.

9. Macros for Code Generation

Rust macros support metaprogramming with two types: declarative macros for pattern matching and procedural macros for generating code. Macros help reduce boilerplate and increase code reuse.

Example

macro_rules! say_hello {
    () => {
        println!("Hello, macro!");
    };
}

fn main() {
    say_hello!();
}

Macros make code concise and reusable, keeping your Rust codebase efficient.

10. Lifetimes and Borrow Checking

Lifetimes prevent dangling references by ensuring references are valid for as long as necessary. They’re key to Rust’s safety guarantees.

Example

fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.len() > s2.len() {
        s1
    } else {
        s2
    }
}

fn main() {
    let result = longest("apple", "banana");
    println!("Longest: {}", result);
}

Rust’s borrow checker ensures that lifetimes are always safe and references are valid.

11. Generics and Type System

Rust’s generic system allows you to write flexible, reusable, and type-safe code. With trait bounds, you can define flexible functions and structures without sacrificing safety.

Example

fn largest<T: PartialOrd>(list: &[T]) -> &T {
    let mut largest = &list[0];
    for item in list {
        if item > largest {
            largest = item;
        }
    }
    largest
}

Generics make it easy to write safe, reusable code without duplicating functionality.

12. Unsafe Code

Rust is safe by default, but in cases where performance or low-level access is needed, unsafe code lets you bypass Rust’s safety checks. Use it sparingly.

Example

fn main() {
    let x: *const i32 = &10;
    unsafe {
        println!("Value at x: {}", *x);
    }
}
Unsafe code is powerful but requires caution, as it bypasses Rust’s guarantees.

13. Async/Await for Concurrency

With async/await, Rust provides non-blocking concurrency, useful for high-performance I/O operations.

Example

use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
    println!("Starting...");
    sleep(Duration::from_secs(1)).await;
    println!("Done!");
}

Async programming in Rust allows efficient and scalable applications.

14. Cargo for Dependency and Package Management

Cargo is Rust’s build system and package manager, helping manage dependencies, build projects, and run tests.

Example

cargo new my_project
cd my_project
cargo build

Cargo simplifies project management, and the extensive ecosystem of crates makes development in Rust easy.

Here is a video Version:

You can find me here: https://francescociulla.

Iterators in Rust - Map, Filter, Reduce

Francesco Ciulla — Tue, 15 Oct 2024 13:34:16 +0000

Iterators in Rust provide a powerful and flexible way to process data efficiently by transforming, filtering, and aggregating elements in a collection.

Unlike traditional loops, Rust’s iterators are lazy—meaning they don't perform any actions until explicitly instructed to. This laziness makes iterators efficient because they only evaluate elements when needed, often combining multiple transformations into a single pass over the data.

In this lesson, we’ll dive into the core of Rust's iterator system and explore how to use methods like .map(), .filter(), and .fold() (similar to reduce) to create expressive, functional code.

Video Version

All the code is available on GitHub (link in video description)

You can find me here: https://francescociulla.com

Introduction to Iterators

The iterator pattern allows you to perform tasks on a sequence of items in turn. An iterator handles the logic of moving from one item to the next and determines when the sequence has finished, freeing you from implementing that logic manually. In Rust, iterators are lazy, meaning they don’t do any work until you call methods that consume the iterator.

For Example:

fn main() {
    let v1 = vec![1, 2, 3];
    let v1_iter = v1.iter();

    for val in v1_iter {
        println!("Got: {}", val);
    }
}

In this code, we create an iterator over a vector using the .iter() method. We then use a for loop to iterate over each value in the iterator and print it. The iterator pattern allows us to abstract away the logic of iterating through the vector, making our code more readable and expressive.

The Iterator Trait and the next Method

The Iterator trait is the core trait for iterators in Rust. It defines the behavior of the .next() method, which returns an Option containing the next value in the sequence. When the iterator is finished, .next() returns None.

All iterators in Rust implement the Iterator trait, which defines a single required method: next.

pub trait Iterator {
    type Item;

    fn next(&mut self) -> Option<Self::Item>;
}

type Item: This is an associated type that specifies the type of items the iterator will yield.
next(): Advances the iterator and returns the next item, or None when the iterator is exhausted.

For Example:

fn main() {
    let v1 = vec![1, 2, 3];
    let mut v1_iter = v1.iter();

    assert_eq!(v1_iter.next(), Some(&1));
    assert_eq!(v1_iter.next(), Some(&2));
    assert_eq!(v1_iter.next(), Some(&3));
    assert_eq!(v1_iter.next(), None);
}

In this code, we create an iterator over a vector and call the .next() method to get the next value in the sequence. We use the assert_eq! macro to check that the values returned by .next() are correct.

Core Types of Iterators

Rust provides three main types of iterators: consuming adaptors, iterator adaptors, and iterators themselves. Consuming adaptors take ownership of the iterator and consume it, producing a single value. Iterator adaptors take an iterator and return a new iterator with a different behavior. Iterators themselves are the base trait for all iterators and define the behavior of the .next() method.

The three main types of iterators are:

iter(): This method creates an iterator that borrows each element of the collection.
into_iter(): This method creates an iterator that takes ownership of each element of the collection.
iter_mut(): This method creates an iterator that mutably borrows each element of the collection.

Let's see the purpose, ownership and use case of each iterator type:

iter()

Purpose: This method creates an iterator that borrows each element of the collection.
Ownership: The original collection remains intact after calling iter().
Use Case: Use iter() when you want to iterate over the collection without taking ownership of it.

For Example:

let numbers = vec![1, 2, 3];

for num in numbers.iter() {
    println!("{}", num); // Outputs each number
}

println!("after iter: {:?}", numbers); // Outputs: [1, 2, 3]

iter_mut()

Purpose: This method creates an iterator that mutably borrows each element of the collection.
Ownership: The original collection remains intact after calling iter_mut().
Use Case: Use iter_mut() when you want to iterate over the collection and modify its elements.

For Example:

let mut numbers = vec![1, 2, 3];
for num in numbers.iter_mut() {
    *num += 1; // Mutates each element by adding 1
    println!("{}", num);
}

println!("{:?}", numbers); // Outputs: [2, 3, 4]

into_iter()

Purpose: This method creates an iterator that takes ownership of each element of the collection.
Ownership: The original collection is consumed after calling into_iter().
Use Case: Use into_iter() when you want to move each element out of the collection.

For Example:

let numbers = vec![1, 2, 3];

for num in numbers.into_iter() {
    println!("{}", num); // Outputs each number
}

// println!("{:?}", numbers); // Error: `numbers` is no longer accessible

Summary table of iterator types:

Here is a summary table of the three main types of iterators in Rust:

Iterator Type	Purpose	Ownership	Use Case
iter()	Creates an iterator that borrows each element of the collection.	Original collection remains intact.	Iterate over the collection without taking ownership.
iter_mut()	Creates an iterator that mutably borrows each element of the collection.	Original collection remains intact.	Iterate over the collection and modify its elements.
into_iter()	Creates an iterator that takes ownership of each element of the collection.	Original collection is consumed.	Move each element out of the collection.

Methods to Modify or Consume Iterators: .map(), .filter(), and .fold()

Rust provides a variety of methods to modify or consume iterators, allowing you to transform, filter, and aggregate elements efficiently. These methods are called iterator adaptors and are chained together to create expressive, functional code.

Some common iterator adaptors include:

.map(): Transforms each element in the iterator.
.filter(): Filters elements based on a predicate function.
.fold(): Aggregates elements into a single value.

Let's explore each of these methods in more detail:

.map() - Transforming Elements

The .map() method transforms each element in the iterator by applying a closure to it. The closure takes an element as input and returns a new value, which is then yielded by the iterator.

let numbers = [1, 2, 3, 4, 5];
let squares: Vec<_> = numbers.iter().map(|&x| x * x).collect();
println!("Map - Squares: {:?}", squares); // Outputs: [1, 4, 9, 16, 25]

In this code, we use the .map() method to square each element in the numbers array. The closure |&x| x * x squares the input x, and the resulting values are collected into a new vector.

.filter() - Filtering Elements

The .filter() method filters elements in the iterator based on a predicate function. The closure takes an element as input and returns a boolean value indicating whether the element should be included in the output.

let numbers = [1, 2, 3, 4, 5];

let evens: Vec<_> = numbers.iter().filter(|&x| x % 2 == 0).collect();

println!("Filter - Evens: {:?}", evens); // Outputs: [2, 4]

In this code, we use the .filter() method to select only the even numbers from the numbers array. The closure |&x| x % 2 == 0 checks if the input x is even, and the resulting values are collected into a new vector.

.fold() - Aggregating Elements

The .fold() method aggregates elements in the iterator into a single value. It takes an initial value and a closure that combines the current accumulator value with each element in the iterator. It's similar to the reduce function in other languages.

let numbers = [1, 2, 3, 4, 5];

let sum = numbers.iter().fold(0, |acc, &x| acc + x);

println!("Fold - Sum: {}", sum); // Outputs: 15

In this code, we use the .fold() method to calculate the sum of all elements in the numbers array. The initial value 0 is passed as the first argument, and the closure |acc, &x| acc + x adds each element x to the accumulator acc.

Summary

Rust’s iterators provide a flexible way to process data efficiently by allowing transformations, filtering, and aggregations over collections. Key takeaways:

Laziness: Iterators do nothing until explicitly consumed.

Ownership and Mutability Control: Choose between iter(), iter_mut(), and into_iter() for precise control over element handling.

Functional Methods: Methods like .map(), .filter(), and .fold() allow expressive, functional transformations.

Iterators give fine-grained control over data ownership and mutability during iteration, making Rust efficient and powerful in processing collections.

Video Version

All the code is available on GitHub (link in video description)

You can find me here: https://francescociulla.com

Iterators in Rust

Francesco Ciulla — Tue, 15 Oct 2024 13:34:16 +0000

Iterators in Rust provide a powerful and flexible way to process data efficiently by transforming, filtering, and aggregating elements in a collection.

In this lesson, we’ll dive into the core of Rust's iterator system and explore how to use methods like .map(), .filter(), and .fold() (similar to reduce) to create expressive, functional code.

Video Version

All the code is available on GitHub (link in video description)

You can find me here: https://francescociulla.com

Introduction to Iterators

For Example:

fn main() {
    let v1 = vec![1, 2, 3];
    let v1_iter = v1.iter();

    for val in v1_iter {
        println!("Got: {}", val);
    }
}

The Iterator Trait and the next Method

All iterators in Rust implement the Iterator trait, which defines a single required method: next.

pub trait Iterator {
    type Item;

    fn next(&mut self) -> Option<Self::Item>;
}

type Item: This is an associated type that specifies the type of items the iterator will yield.
next(): Advances the iterator and returns the next item, or None when the iterator is exhausted.

For Example:

fn main() {
    let v1 = vec![1, 2, 3];
    let mut v1_iter = v1.iter();

    assert_eq!(v1_iter.next(), Some(&1));
    assert_eq!(v1_iter.next(), Some(&2));
    assert_eq!(v1_iter.next(), Some(&3));
    assert_eq!(v1_iter.next(), None);
}

Core Types of Iterators

The three main types of iterators are:

iter(): This method creates an iterator that borrows each element of the collection.
into_iter(): This method creates an iterator that takes ownership of each element of the collection.
iter_mut(): This method creates an iterator that mutably borrows each element of the collection.

Let's see the purpose, ownership and use case of each iterator type:

iter()

Purpose: This method creates an iterator that borrows each element of the collection.
Ownership: The original collection remains intact after calling iter().
Use Case: Use iter() when you want to iterate over the collection without taking ownership of it.

For Example:

let numbers = vec![1, 2, 3];

for num in numbers.iter() {
    println!("{}", num); // Outputs each number
}

println!("after iter: {:?}", numbers); // Outputs: [1, 2, 3]

iter_mut()

Purpose: This method creates an iterator that mutably borrows each element of the collection.
Ownership: The original collection remains intact after calling iter_mut().
Use Case: Use iter_mut() when you want to iterate over the collection and modify its elements.

For Example:

let mut numbers = vec![1, 2, 3];
for num in numbers.iter_mut() {
    *num += 1; // Mutates each element by adding 1
    println!("{}", num);
}

println!("{:?}", numbers); // Outputs: [2, 3, 4]

into_iter()

Purpose: This method creates an iterator that takes ownership of each element of the collection.
Ownership: The original collection is consumed after calling into_iter().
Use Case: Use into_iter() when you want to move each element out of the collection.

For Example:

let numbers = vec![1, 2, 3];

for num in numbers.into_iter() {
    println!("{}", num); // Outputs each number
}

// println!("{:?}", numbers); // Error: `numbers` is no longer accessible

Summary table of iterator types:

Here is a summary table of the three main types of iterators in Rust:

Iterator Type	Purpose	Ownership	Use Case
iter()	Creates an iterator that borrows each element of the collection.	Original collection remains intact.	Iterate over the collection without taking ownership.
iter_mut()	Creates an iterator that mutably borrows each element of the collection.	Original collection remains intact.	Iterate over the collection and modify its elements.
into_iter()	Creates an iterator that takes ownership of each element of the collection.	Original collection is consumed.	Move each element out of the collection.

Methods to Modify or Consume Iterators: .map(), .filter(), and .fold()

Some common iterator adaptors include:

.map(): Transforms each element in the iterator.
.filter(): Filters elements based on a predicate function.
.fold(): Aggregates elements into a single value.

Let's explore each of these methods in more detail:

.map() - Transforming Elements

The .map() method transforms each element in the iterator by applying a closure to it. The closure takes an element as input and returns a new value, which is then yielded by the iterator.

let numbers = [1, 2, 3, 4, 5];
let squares: Vec<_> = numbers.iter().map(|&x| x * x).collect();
println!("Map - Squares: {:?}", squares); // Outputs: [1, 4, 9, 16, 25]

In this code, we use the .map() method to square each element in the numbers array. The closure |&x| x * x squares the input x, and the resulting values are collected into a new vector.

.filter() - Filtering Elements

let numbers = [1, 2, 3, 4, 5];

let evens: Vec<_> = numbers.iter().filter(|&x| x % 2 == 0).collect();

println!("Filter - Evens: {:?}", evens); // Outputs: [2, 4]

.fold() - Aggregating Elements

let numbers = [1, 2, 3, 4, 5];

let sum = numbers.iter().fold(0, |acc, &x| acc + x);

println!("Fold - Sum: {}", sum); // Outputs: 15

Summary

Rust’s iterators provide a flexible way to process data efficiently by allowing transformations, filtering, and aggregations over collections. Key takeaways:

Laziness: Iterators do nothing until explicitly consumed.

Ownership and Mutability Control: Choose between iter(), iter_mut(), and into_iter() for precise control over element handling.

Functional Methods: Methods like .map(), .filter(), and .fold() allow expressive, functional transformations.

Iterators give fine-grained control over data ownership and mutability during iteration, making Rust efficient and powerful in processing collections.

Video Version

All the code is available on GitHub (link in video description)

You can find me here: https://francescociulla.com