I used the Fibonacci sequence to test the speed of recursive calls in different
languages. Take the results with a grain of salt because my computer is not a
controlled environment. I found that Python was slower than I expected, while
JavaScript was faster than I expected. As for Bash, I found it pointless to
continue measuring after the 5-hour mark.

Execution times for calculating the 39th term of the Fibonacci sequence:

Language
Compiler/Interpreter
Flags
Time (sec)
C
gcc 12.3.0
-O3 -Ofast
0.124
C++
g++ 12.3.0
-O3 -Ofast
0.125
Rust
rustc 1.73.0
-C opt-level=3
0.247
Java
javac/java 17.0.7
None
0.460
JavaScript
node 21.2.0
None
0.802
Lua
lua 5.2.4
None
8.192
Python
python3 3.11.6
None
10.828
Perl
perl 5.38.2
None
38.966
Bash
bash
None
18000.000

Implementations
C
/**
* @file
* @brief Calculate the a Fibonacci sequence number from user input.
*/
#include <stdio.h>
#include <stdlib.h>
/**
* @brief Calculate a Fibonacci sequence number.
*
* @param term The sequence number to produce. Don't use large
* numbers as the time complexity is exponential.
* @return The sequence number.
*/
int fibonacci ( int term ) {
// Base case.
if ( term <= 1 ) {
return term ;
}
// Recursive step.
return fibonacci ( term - 1 ) + fibonacci ( term - 2 );
}
/**
* @brief Calculate a Fibonacci sequence number from user input.
*
* @param argc The argument count.
* @param argv The argument vector.
* @return The error code.
*/
int main ( int argc , char ** argv ) {
if ( argc > 1 ) {
int term = atoi ( argv [ 1 ]);
int result = fibonacci ( term );
printf ( "%d \n " , result );
}
return 0 ;
}

C++
/**
* @file
* @brief Calculate a Fibonacci sequence number from user input.
*/
#include <iostream>
/**
* @brief Calculate a Fibonacci sequence number.
*
* @param term The sequence number to produce. Don't use large
* numbers as the time complexity is exponential.
* @return The sequence number.
*/
int fibonacci ( int term ) {
// Base case.
if ( term <= 1 ) {
return term ;
}
// Recursive step.
return fibonacci ( term - 1 ) + fibonacci ( term - 2 );
}
/**
* @brief Calculate a Fibonacci sequence number from user input.
*
* @param argc The argument count.
* @param argv The argument vector.
* @return The error code.
*/
int main ( int argc , char ** argv ) {
if ( argc > 1 ) {
int term = std :: stoi ( argv [ 1 ]);
int result = fibonacci ( term );
std :: cout << result << std :: endl ;
}
return 0 ;
}

Rust
//! Calculate a Fibonacci sequence number from user input.
use std :: env :: args ;
/// Calculate a Fibonacci sequence number.
///
/// * `term`: The sequence number to produce. Don't use large numbers as the
/// time complexity is exponential.
fn fibonacci ( term : i32 ) -> i32 {
// Base case.
if term <= 1 {
return term ;
}
// Recursive step.
fibonacci ( term - 1 ) + fibonacci ( term - 2 )
}
/// Calculate a Fibonacci sequence number from user input.
fn main () {
let arguments : Vec < String > = args () .collect ();
if let Some ( argument ) = arguments .get ( 1 ) {
let term : i32 = argument .parse () .unwrap_or ( 0 );
let result = fibonacci ( term );
println! ( "{}" , result );
}
}

Java
/**
* Calculate a Fibonacci sequence number from user input.
*/
class Fibonacci {
/**
* Calculate a Fibonacci sequence number.
*
* @param term The sequence number to produce. Don't use large numbers as
* the time complexity is exponential.
*
* @return The sequence number.
*/
public static int fibonacci ( int term ) {
// Base case.
if ( term <= 1 ) {
return term ;
}
// Recursive step.
return fibonacci ( term - 1 ) + fibonacci ( term - 2 );
}
/**
* Calculate a Fibonacci sequence number from user input.
*
* @param args The command-line arguments.
*/
public static void main ( String [] args ) {
if ( args . length > 0 ) {
int term = Integer . parseInt ( args [ 0 ]);
int result = fibonacci ( term );
System . out . println ( result );
}
}
}

JavaScript
#!/usr/bin/env node
/**
* @module Calculate a Fibonacci sequence number from user input.
*/
/**
* Calculate a Fibonacci sequence number.
*
* @param {number} term The sequence number to produce. Don't use large numbers
* as the time complexity is exponential.
* @returns {number} The sequence number.
*/
function fibonacci ( term ) {
// Base case.
if ( term <= 1 ) {
return term ;
}
// Recursive step.
return fibonacci ( term - 1 ) + fibonacci ( term - 2 );
}
if ( process . argv . length > 2 ) {
const term = parseInt ( process . argv [ 2 ]);
const result = fibonacci ( term );
console . log ( result );
}

Lua
#!/usr/bin/env lua
--- @module Calculate a Fibonacci sequence number from user input.
--- Calculate a Fibonacci sequence number.
--- @param term number The sequence number to produce. Don't use large numbers as
--- the time complexity is exponential.
--- @return number
local function fibonacci ( term )
-- Base case.
if term <= 1 then
return term ;
end
-- Recursive step.
return fibonacci ( term - 1 ) + fibonacci ( term - 2 );
end
if # arg >= 1 then
local term = tonumber ( arg [ 1 ]) or 0 ;
local result = fibonacci ( term );
print ( result );
end

Python
#!/usr/bin/python3
"""Calculate a Fibonacci sequence number from user input."""
from sys import argv
def fibonacci ( term : int ) -> int :
"""Calculate a Fibonacci sequence number.
Args:
term (int): The sequence number to produce. Don't use large numbers as
the time complexity is exponential.
Returns:
int: The sequence number.
"""
# Base case.
if term <= 1 :
return term
# Recursive step.
return fibonacci ( term - 1 ) + fibonacci ( term - 2 )
def main ():
"""Calculate a Fibonacci sequence number from user input."""
if len ( argv ) >= 2 :
term = int ( argv [ 1 ])
result = fibonacci ( term )
print ( result )
if __name__ == "__main__" :
main ()

Perl
#!/usr/bin/env perl
use strict ;
use warnings ;
use feature ' say ';
sub fibonacci {
my $term = shift ;
# Base case.
if ( $term <= 1 ) {
return $term ;
}
# Recursive step.
return fibonacci ( $term - 1 ) + fibonacci ( $term - 2 );
}
sub main {
if ( scalar @ARGV >= 1 ) {
my $value = fibonacci ( int ( $ARGV [ 0 ]));
say ( $value );
}
}
unless ( caller ) {
main ();
}
__END__
=head1 Methods
=head2 main
Calculate a Fibonacci sequence number from user input.
=head2 fibonacci
Calculate a Fibonacci sequence number.
Arguments:
=over
=item C<$term>: C<int>
The sequence number to produce. Don't use large numbers as
the time complexity is exponential.
=back
Return:
=over
=item C<int>
The sequence number.
=back

Bash
#!/usr/bin/bash
# Calculate a Fibonacci sequence number from user input.
# Exit on errors and undefined variables.
set -eu
################################################################################
# Calculate a Fibonacci sequence number.
# Arguments:
# $1: int The sequence number to produce. Don't use large numbers as
# the time complexity is exponential.
# Outputs:
# int The sequence number.
################################################################################
fibonacci() {
declare -ir term = $1
# Base case.
if (( term <= 1 )) ; then
echo $term
return
fi
# Recursive step.
echo $(( $( fibonacci $(( term - 1 )) ) + $( fibonacci $(( term - 2 )) ) ))
}
fibonacci $1