From PHP to Rust

After spending years building websites with PHP (mainly laravel), I recently dove into Rust, and wow it was a very interesting experience.

Today, I want to share my experience transitioning from PHP to Rust, especially for those of you who might be curious about making a similar jump.

My goal was to learn Rust not to replace PHP, but to use it as a complement to PHP for use cases where it makes sense to use a performant language.

Why Rust, Though?

I know what you're thinking: "PHP works fine for me, why bother?"

That's exactly what I thought too!

But here's the thing - while PHP is fantastic for web development, Rust opened my eyes to a whole new world of programming concepts that actually made me a better PHP developer too.

Types Everywhere!

Coming from PHP's dynamic typing, Rust's strict type system initially felt like wearing a straitjacket.

Remember how in PHP we can do this:

<?php
$number = "42";  // String
$number = $number + 8;  // PHP: "Eh, I'll convert that for you"

But in Rust, we can't do that:

let number = "42";  // This is a &str
let result = number.parse::<i32>().unwrap() + 8;  // We need to explicitly parse

This is a huge difference which at first, this felt excessive.

But after a while, I started appreciating how these "restrictions" prevented many bugs I used to spend hours debugging in PHP.

The Ownership System

Remember how in PHP we don't really think about memory management? We just create variables and PHP's garbage collector handles the rest.

Rust's ownership system is completely different, and it's probably the biggest mental shift you'll need to make. Here's a PHP example we're all familiar with:

$users = ["Alice", "Bob"];
$active_users = $users;
$users[] = "Charlie";
print_r($active_users);  // Original array isn't affected

In Rust, this seemingly simple operation needs more thought:

let users = vec!["Alice", "Bob"];
let active_users = users;  // users is now "moved"
// println!("{:?}", users);  // This would cause an error!

Error Handling

One thing that took me a while to appreciate was Rust's Result type. In PHP, we're used to try-catch blocks:

try {
    $file = file_get_contents("config.json");
} catch (Exception $e) {
    // Handle error
}

Rust's approach is different but elegant once you get used to it:

let file_content = match fs::read_to_string("config.json") {
    Ok(content) => content,
    Err(e) => {
        // Handle error
        String::new()
    }
};

What I Love About Rust Now

• Performance: My CLI tools run blazingly fast compared to PHP scripts.
• Safety: The compiler catches so many potential issues before they become runtime problems.
• Package Management: Cargo is a dream compared to managing PHP dependencies. Community: Rustaceans are incredibly welcoming and helpful!

Here's a comparison of the performance of Laravel and Axum (a Rust web framework):

On average, Axum handled about 462,480 RPS while Laravel processed around 7,865 RPS.

That means the Rust-based Axum framework processed requests approximately 58 times faster than Laravel in this simple benchmark!

The Hard Parts (Let's Be Honest)

The learning curve is steep. Like, really steep.

Fighting with the borrow checker can be frustrating at first. Compile times can be longer than PHP's instant gratification.

Some simple tasks require more code than their PHP equivalents.

Tips for PHP Developers Learning Rust

If you're thinking about learning Rust, here's what helped me:

• Start with CLI Tools: Don't try to build a web server right away. Small command-line tools are perfect for learning.
• Embrace the Compiler: The error messages are your friends, not your enemies.
• Think in Types: Start thinking about types before you write code - it helps! Keep PHP Knowledge: Many patterns from PHP (like SOLID principles) are still valuable in Rust.

My Current Development Setup

I now use both languages: PHP for web applications where its ecosystem shines, and Rust for performance-critical components, CLI tools, and system programming.

They complement each other beautifully!

Conclusion

Learning Rust has been challenging but incredibly rewarding.

It's made me think differently about programming and improved my PHP code too. If you're on the fence about learning Rust, I'd say go for it! The journey is worth it, even if you don't end up using Rust in your day-to-day work.

Happy coding! 🦀✨