DEV Community: Francesco Ciulla

Rust Borrow Checker 2.0 is Finally Here

Francesco Ciulla — Sun, 09 Aug 2026 07:57:10 +0000

Perfectly safe Rust code that wouldn't compile until today is now finally compiling! The wait is over.

Polonius: The Next Evolution of Rust's Borrow Checker

Rust's borrow checker keeps our code safe from memory bugs. We all love it, but sometimes the current version, Non-Lexical Lifetimes (NLL), is just a bit too strict. It can throw errors on code that is completely fine, especially when you use conditional branches or work with common data structures.

That is where Polonius comes in. It is the next generation of the borrow checker, and it is now enabled by default on Rust Nightly.

I wanted to see this in action, so I put it to the test with some actual Rust code. I was getting my morning espresso when I ran a very minimalistic reborrow function with an if true statement. I ran the exact same safe code with the two different borrow checkers. With the stable compiler, it threw the classic "cannot borrow as mutable more than once at a time" error. Then I ran it on Nightly with Polonius, and it compiled perfectly. I was genuinely shocked. It honestly looked like witchcraft to see the exact same code fail on one side and pass on the other.

I then moved to a bigger, more realistic example using a HashMap and mutable references with Some and None branches. NLL hates this pattern and complains about multiple mutable borrows. Polonius easily follows the real control flow paths. It understands that the initial reference is no longer alive in the None branch, allowing the code to compile without weird workarounds. I even turned Polonius off while still using Nightly just to prove it was the new borrow checker making the difference.

Of course, Polonius Alpha is still in alpha. It does more precise analysis, which means the compiler has to do a little more work. I took a look at the Rust team's benchmarks across the top 10,000 downloaded crates on crates.io. There are some compile-time performance regressions, but they are typically minimal.

Touching a core part of the language like the borrow checker is a brave move! It shows the Rust project team is going in the direction of correctness and giving more power to developers, rather than just focusing on pure compilation speed. They want this to be the best version of Rust possible.

If you want to read more about the technical details behind this update, check out the official Rust blog post.

[Boost]

Francesco Ciulla — Tue, 28 Jul 2026 16:01:11 +0000

Francesco Ciulla

Jul 28

I Tried Topcoat: Rust’s New Full-Stack Web Framework

#rust #webdev #programming #opensource

2 min read

I Tried Topcoat: Rust’s New Full-Stack Web Framework

Francesco Ciulla — Tue, 28 Jul 2026 15:35:07 +0000

Rust web development just got more interesting.

If you prefer a video version:

A few days ago, I spoke with Carl Lerche and Julien Scholz about Topcoat, a new batteries-included framework for building full-stack reactive web applications with Rust.

Now I have finally tried it myself.

Topcoat comes from the ecosystem behind Tokio and Axum, but it aims to provide a very different experience: routing, server-side rendering, reactive components, UI tooling, asset bundling, and hot reload in one framework.

A simple Topcoat application

This is what a basic application looks like:

use topcoat::{
    Result,
    router::{Router, RouterBuilderDiscoverExt, page},
    view::{component, view},
};

#[tokio::main]
async fn main() {
    topcoat::start(Router::builder().discover().build())
        .await
        .unwrap();
}

#[page("/")]
async fn home() -> Result {
    view! {
        <!DOCTYPE html>
        <html>
            <body>
                hello(name: "World")
            </body>
        </html>
    }
}

#[component]
async fn hello(name: &str) -> Result {
    view! { <h1>"Hello, " (name) "!"</h1> }
}

The syntax feels surprisingly familiar if you have used server-rendered frameworks before.

Pages and components are written in Rust, while the view! macro keeps the HTML structure easy to understand.

What surprised me

My first experience was better than expected.

The setup was simple, the basic example was actually basic, and the development server provided working hot reload.

That last part may sound normal to JavaScript developers, but it makes a huge difference for the Rust developer experience.

Topcoat includes or plans to support:

Server-side rendering
Reactive components
Module-based routing
Tailwind integration
Reusable UI components
Asset bundling
Fonts and icons
Cookies and sessions
Database integrations

The experience feels closer to frameworks such as Laravel, Django, Rails, or Next.js, while allowing developers to build the application in Rust.

Is Topcoat ready for production?

Topcoat is still at an early stage.

Breaking changes should be expected, and I would not migrate an important production application to it yet.

However, the initial developer experience is already promising.

The combination of Rust’s performance and type safety with the productivity of a batteries-included framework is something I have wanted to see for a long time.

I’m starting a Topcoat series

This video officially starts a new YouTube series in which I will test Topcoat, build applications with it, and follow its development.

I also published a conversation with Carl Lerche and Julien Scholz about the ideas behind the framework:

https://youtu.be/iP9iL4dkiB0

I am genuinely curious to see where this project goes.

Would you use a full-stack Rust framework like Topcoat? What should I build with it next?

Better than Next.js? Is Rust Finally Ready for Full-Stack Web Development? Introducing Topcoat

Francesco Ciulla — Thu, 23 Jul 2026 10:26:15 +0000

There is a super-new Rust Web Framework in town, and it's name is Topcoat

Rust is already a solid choice for backend development, especially with frameworks like Axum. But building a complete web application in Rust still means connecting many different libraries yourself. That is the problem Topcoat wants to solve.

Topcoat is a new batteries-included framework created by Carl Lerche and Julien Scholz for building full-stack, reactive web applications entirely in Rust.

Announcement: https://tokio.rs/blog/2026-07-22-announcing-topcoat
GitHub: https://github.com/tokio-rs/topcoat

Prefer a video version? I discussed Topcoat directly with Carl Lerche, the creator of Tokio, and Julien Scholz, the creator of Topcoat.

What is Topcoat?

Topcoat is fully server-rendered.

Your components can be asynchronous, access the database, load application state, and check user permissions directly on the server.

A minimal application looks like this:

#[tokio::main]
async fn main() {
    topcoat::start(Router::builder().discover().build())
        .await
        .unwrap();
}

#[page("/")]
async fn home() -> Result {
    view! {
        <!DOCTYPE html>
        <html>
            <head>
                <title>"Hello world"</title>
                topcoat::dev::script()
            </head>
            <body>
                <h1>"Hello from Topcoat!"</h1>
            </body>
        </html>
    }
}

Reactivity without WebAssembly

Frameworks like Leptos and Dioxus can run Rust in the browser through WebAssembly.

Topcoat takes a different route.

It renders the application on the server and adds client-side reactivity through small reactive instructions. It can also re-render parts of the UI on the server and replace only the section that changed.

The approach is closer to HTMX or Hotwire than to a traditional React-style SPA.

This makes Topcoat especially interesting for:

Admin panels
Internal tools
Blogs and content platforms
Online stores
Data-heavy applications

For highly interactive browser applications, a client-heavy framework may still be a better fit.

Is it replacing Axum?

No. Axum is still a great choice for APIs and lower-level HTTP endpoints.

Topcoat works at a higher level and tries to remove the boilerplate between routing, components, HTML rendering, assets, and reactive updates.

A project could easily use both.

Why Topcoat matters

Rust already has many excellent libraries, but it has been missing a more opinionated, integrated experience similar to Rails, Laravel, or Next.js.

Topcoat is moving in that direction with:

Server-rendered components
An asset pipeline
Tailwind-based UI components
Fonts and icon integrations
Request-level memoization
Authentication close to the protected component
Planned integration with the Toasty ORM

It is still early, and the team is open about the current limitations of its reactivity system.

Still, this feels like an important step for Rust web development.

Topcoat is not here to replace every existing framework. It is trying to make it much easier to build complete, server-rendered applications without leaving Rust.

Would you try it for your next internal tool or dashboard?

Watch the full discussion with Carl Lerche and Julien Scholz:

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