This simple benchmark compares the speed at which different languages are able
to sum values:

$$\sum _{i=0}^{10000}i$$
Unsurprisingly, the Rust implementation was the fastest. This is likely due to
Rust being a compiled language while the other languages are interpreted. This
shows that Bash is not designed to perform arithmetic operations since it is
slow at addition and exceptionally slow at recursion .
Instead, Bash should be used for calling external commands since it is the
fastest command interpreter .

Execution times for calculating the series sum of 100,000:

Language
Mean [ms]
Min [ms]
Max [ms]
Relative
rustc 1.79.0
24.4 ± 11.2
7.7
39.4
1.00
perl 5.38.2
28.1 ± 11.5
9.3
43.5
1.15 ± 0.71
python 3.11.9
35.1 ± 12.6
16.5
48.1
1.44 ± 0.84
node 22.2.0
46.7 ± 10.5
33.1
63.2
1.91 ± 0.98
bash 5.2.26
307.2 ± 13.6
289.6
325.4
12.59 ± 5.81

Implementations
Rust
# !/ usr / bin / env cached - nix - shell
/*
#!nix-shell -i rust-script -p rustc -p rust-script -p cargo
*/
//! Do arithmetic operations.
use std :: env :: args ;
/// Perform sum operations.
///
/// * `operations`: The number of operations to perform.
///
/// Returns the series sum.
fn do_sum ( operations : i32 ) -> i32 {
let mut counter = 0 ;
for i in 0 .. operations + 1 {
counter = counter + i ;
}
return counter ;
}
/// Do the number of arithmetic operations specified by the user input.
fn main () {
let arguments : Vec < String > = args () .collect ();
if let Some ( argument ) = arguments .get ( 1 ) {
let operations : i32 = argument .parse () .unwrap_or ( 0 );
let result = do_sum ( operations );
println! ( "{}" , result );
}
}

Perl
#!/usr/bin/env perl
use strict ;
use warnings ;
=head1 DESCRIPTION
Do arithmetic operations.
=head1 FUNCTIONS
=over
=item count($total)
Perform sum operations.
$total C<int> is the number of operations to perform.
Returns C<int>, the series sum.
=back
=cut
sub doSum {
my $total = shift ;
my $sum = 0 ;
for my $i ( 1 .. $total ) {
$sum = $sum + $i ;
}
return $sum ;
}
print doSum shift ;

Python
#!/usr/bin/env python3
"""Do arithmetic operations."""
from sys import argv
def do_sum ( operations : int ) -> int :
"""Perform sum operations.
Args:
operations (int): The number of operations to perform.
Returns:
int: The series sum.
"""
counter = 0
for i in range ( operations + 1 ):
counter = counter + i
return counter
def main ():
"""Calculate a Fibonacci sequence number from user input."""
term = int ( argv [ 1 ])
print ( do_sum ( term ))
if __name__ == "__main__" :
main ()

JavaScript
#!/usr/bin/env node
/**
* @module Do arithmetic operations.
*/
/**
* Perform sum operations.
*
* @param {number} operations The number of operations to perform.
* @returns {number} The series sum.
*/
function doSum ( operations ) {
let sum = 0 ;
for ( let i = 0 ; i <= operations ; i ++ ) {
sum = sum + i ;
}
return sum ;
}
const term = parseInt ( process . argv [ 2 ]);
console . log ( doSum ( term ));

Bash
#!/usr/bin/env bash
# Do arithmetic operations.
#######################################
# Perform sum operations.
# Arguments:
# $1: The number of operations to perform
# Returns:
# int: The series sum.
#######################################
count() {
local sum = 0
for (( i = 0; i <= $1 ; i++)) ; do
(( sum = sum + i))
done
echo $sum
}
count " $1 "