Performance Benchmarks

How Strada compares to Perl, Python, Ruby, Node.js, and PHP.

Strada compiles to C, then to native machine code via GCC with link-time optimization. These benchmarks compare Strada against Perl, Python, Ruby, Node.js, and PHP across five categories: compute, functions, strings, data structures, and object-oriented programming.

Results

All times are wall-clock seconds, best of 3 runs. Lower is better.

Strada vs Perl

Strada is a natural upgrade from Perl — same syntax feel, dramatically better performance. The biggest gains come from compiled function calls and integer arithmetic, where Perl's interpreter dispatch loop creates massive overhead.

Strada vs Python

Python's interpreted bytecode VM adds overhead to every operation. Strada compiles to native code, making it dramatically faster across the board. Python's string concatenation with += is catastrophically slow due to immutable string copies — over 2,000x slower than Strada.

Strada vs Ruby

Ruby's YARV interpreter and YJIT have improved performance significantly, but Strada's native compilation still wins across every benchmark. Ruby's string concatenation suffers from similar allocation overhead as Python.

Strada vs Node.js

V8's JIT compiler makes Node.js a strong competitor. With Strada's tagged-integer arithmetic and constructor-fusion work, Strada now wins all five benchmarks — including OOP, where Node's hidden classes and inline caches used to edge ahead.

Strada vs PHP

PHP 8.3's JIT and optimized hash tables make it competitive at data-structure and string workloads, but Strada wins all five benchmarks. The gap is widest on compute, function calls, and OOP, where native compilation and constructor fusion eliminate interpreter overhead; strings and hash insertion are closer but still favor Strada.

Why Strada is Fast

What Each Benchmark Tests

Compute

Sum of 50 million integers and recursive Fibonacci(35) run 30 times. Tests raw numeric throughput, function call overhead, and recursive call performance.

func fib(int $n) int {
    if ($n < 2) { return $n; }
    return fib($n - 1) + fib($n - 2);
}

Functions

Millions of function calls with multiple arguments, plus Ackermann's function for deep recursion. Tests call/return overhead, argument passing, and stack management.

Strings

Concatenation of 500,000 strings, splitting 100K strings, and regex search-and-replace on 200K iterations. Tests string allocation, PCRE2 regex compilation, and in-place mutation.

Array/Hash

Pushes 2 million elements, creates a 500K-entry hash with lookups, and deletes all entries. Tests dynamic array growth, hash table insertion, lookup, and deletion.

OOP

Creates 1.2 million objects with has attributes, calls accessor methods, computes distances, and performs isa() checks. Tests object construction, method dispatch, accessor performance, and inheritance.

package Point;
has rw int $x = 0;
has rw int $y = 0;

func distance_sq(scalar $self) int {
    return $self->x() * $self->x() + $self->y() * $self->y();
}

Running the Benchmarks

All benchmark source files are in the benchmarks/ directory with implementations in Strada, Perl, Python, Ruby, Node.js, and PHP:

# Run all benchmarks with the automated script
cd benchmarks
bash run_benchmarks.sh

# Or run individual benchmarks
./strada benchmarks/bench_compute.strada
time ./bench_compute
time perl benchmarks/bench_compute.pl
time python3 benchmarks/bench_compute.py
time ruby benchmarks/bench_compute.rb
time node benchmarks/bench_compute.js
time php benchmarks/bench_compute.php