What Makes Rust Stand Out?

use std::hint::black_box;
use std::time::Instant;

fn fibonacci(n: usize) -> Vec<u64> {
    let mut fibonacci: Vec<u64> = Vec::with_capacity(n);  // 👈 memory allocation on the heap
    fibonacci.push(0);
    fibonacci.push(1);
    for i in 2..n {
        let next: u64 = fibonacci[i - 1] + fibonacci[i - 2];
        fibonacci.push(next);
    }
    fibonacci
}

fn main() {
    let mut total: f64 = 0.0;
    const N: usize = 10_000_000;

    for _ in 1..=20 {   // 👈 20 iterations
        let start: Instant = Instant::now();
        black_box(fibonacci(black_box(N)));  // 👈 black_box is used to remove noisy noise
        let elapsed: f64 = start.elapsed().as_secs_f64();
        total += elapsed;
    }

    let avg_time: f64 = total / 20.0; // 👈 average
    println!("Average time taken: {} s", avg_time);
}

// cmd: $ cargo run --release
// Output: Average time taken: 0.03736314269999994 s

import java.util.ArrayList;
import java.util.List;

public class Fibonacci {
    public static List<Long> fibonacci(int n) {
        List<Long> fibonacci = new ArrayList<>(n); // 👈 ArrayList is intentional here, comparing heap allocation speed.
        fibonacci.add(0L);
        fibonacci.add(1L);
        for (int i = 2; i < n; i++) {
            long next = fibonacci.get(i - 1) + fibonacci.get(i - 2);
            fibonacci.add(next);
        }
        return fibonacci;
    }

    public static void main(String[] args) {
        double total = 0.0;
        final int N = 10_000_000;

        for (int count = 1; count <= 24; count++) {
            long startTime = System.nanoTime();
            List<Long> result = fibonacci(N);
            long endTime = System.nanoTime();
            double elapsed = (endTime - startTime) / 1_000_000_000.0;
            if (count > 4) { // 👈 Exclude JIT
                total += elapsed;
            }
        }

        double avgTime = total / 20.0; // 👈 24 - 5 + 1 = 20
        System.out.println("Average time taken: " + avgTime + " s");
    }
}

// cmd: $ javac Fibonacci.java && java Fibonacci
// Output: Average time taken: 0.121429435499999 s

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

long* fibonacci(int n) {
    long* fibonacci = (long*)malloc(n * sizeof(long)); // 👈 memory allocation on the heap.
    fibonacci[0] = 0;
    fibonacci[1] = 1;
    for (int i = 2; i < n; i++) {
        fibonacci[i] = fibonacci[i - 1] + fibonacci[i - 2];
    }
    return fibonacci;
}

int main() {
    double total = 0.0;
    const int N = 10000000;

    for (int count = 1; count <= 20; count++) {
        clock_t start = clock();
        long* result = fibonacci(N);
        clock_t end = clock();
        double elapsed = (double)(end - start) / CLOCKS_PER_SEC;
        total += elapsed;
        free(result); // Remember to free the dynamically allocated memory
    }

    double avg_time = total / 20.0;
    printf("Average time taken: %f s\n", avg_time);
    return 0;
}

// cmd: $ gcc -O3 -march=native -mtune=native -Wall file_name.c -o file_name && ./file_name
// Output: Average time taken: 0.033067 s

use std::thread;
use std::sync::{Arc, Mutex};

fn main() {
    let mut handles = vec![];
    let num_threads = 5;
    let counters = Arc::new(Mutex::new(vec![0; num_threads]));

    for t in 0..num_threads {
        let counters_ref = Arc::clone(&counters);
        let handle = thread::spawn(move || {
            for _ in 0..100_000 {
                // 👇 Each thread acquires a lock on the mutex
                let mut counters = counters_ref.lock().unwrap();
                counters[t] += 1;
            }
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    let counters = counters.lock().unwrap();
    let total_counter: usize = counters.iter().sum();

    println!("Final counter value: {}", total_counter);
}

// cmd: $ cargo run --release
// Output: Final counter value: 500000

import threading

def thread_function(counters, t):
    for _ in range(100_000):
        with counters_lock:
            counters[t] += 1

num_threads = 5
counters = [0] * num_threads
counters_lock = threading.Lock()

threads = []

for t in range(num_threads):
    thread = threading.Thread(target=thread_function, args=(counters, t))
    threads.append(thread)
    thread.start()

for thread in threads:
    thread.join()

total_counter = sum(counters)

print(f"Final counter value: {total_counter}")

# cmd: $ python file_name.py
# Output: Final counter value: 500000

fn divide(a: f64, b: f64) -> Option<f64> {
    if b == 0.0 {
        None
    } else {
        Some(a / b)
    }
}

fn main() {
    let result = divide(10.0, 2.0);
    match result {
        Some(res) => println!("Result: {}", res),
        None => println!("Error: Cannot divide by zero"),
    }
}

// cmd: $ cargo run --release
// Output: Result: 5

public class OptionHandling {
    public static Double divide(double a, double b) {
        if (b == 0.0) {
            return null;
        } else {
            return a / b;
        }
    }

    public static void main(String[] args) {
        Double result = divide(10.0, 2.0);
        if (result != null) {
            System.out.println("Result: " + result);
        } else {
            System.out.println("Error: Cannot divide by zero");
        }
    }
}

// cmd: javac OptionHandling.java && java OptionHandling
// Output: Result: 5