Performance Comparison of Programming Languages: Counting from 1 to 1 Billion

Different programming languages have different performance characteristics, especially when it comes to computational tasks. In this article, we will compare the performance of several popular programming languages by measuring the time it takes each language to count from 1 to 1 billion. The languages we will cover include C, C++, Java, Python, Go, C#, and JavaScript.

Overview of the Task

The task is simple: write a loop in each programming language that counts from 1 to 1 billion, and measure the time it takes to complete the task. We will use each language’s built-in functions to measure the time taken.

The Code and Execution Process

Below is the code for each language, along with instructions on how to run it from the command line.

C

#include 
#include 

int main() {
    clock_t start = clock();
    
    for (long long i = 1; i <= 1000000000; i++);

    clock_t end = clock();
    double duration = (double)(end - start) / CLOCKS_PER_SEC;
    printf("C: Time taken: %f seconds\n", duration);

    return 0;
}

To compile and run the C code:

gcc -o count_c count.c
./count_c

C++

#include 
#include 

int main() {
    auto start = std::chrono::high_resolution_clock::now();
    
    for (long long i = 1; i <= 1000000000; ++i);

    auto end = std::chrono::high_resolution_clock::now();
    std::chrono::duration duration = end - start;
    std::cout << "C++: Time taken: " << duration.count() << " seconds" << std::endl;

    return 0;
}

To compile and run the C++ code:

g++ -o count_cpp count.cpp
./count_cpp

Java

public class Main {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();

        for (long i = 1; i <= 1000000000; i++);

        long end = System.currentTimeMillis();
        System.out.println("Java: Time taken: " + (end - start) / 1000.0 + " seconds");
    }
}

To compile and run the Java code:

javac Main.java
java Main

Python

import time

start = time.time()

for i in range(1, 1000000001):
    pass

end = time.time()
print(f"Python: Time taken: {end - start} seconds")

To run the Python code:

python count.py

Go

package main

import (
    "fmt"
    "time"
)

func main() {
    start := time.Now()

    for i := 1; i <= 1000000000; i++ {}

    duration := time.Since(start)
    fmt.Printf("Go: Time taken: %v seconds\n", duration.Seconds())
}

To run the Go code:

go run count.go

C#

using System;

class Program {
    static void Main() {
        var watch = System.Diagnostics.Stopwatch.StartNew();

        for (long i = 1; i <= 1000000000; i++) { }

        watch.Stop();
        Console.WriteLine($"C#: Time taken: {watch.Elapsed.TotalSeconds} seconds");
    }
}

To compile and run the C# code:

mcs -out:count_cs.exe count.cs
mono count_cs.exe

JavaScript (Node.js)

console.time('JavaScript');

for (let i = 1; i <= 1000000000; i++);

console.timeEnd('JavaScript');

To run the JavaScript code:

node count.js

Results

Here are the results after running the code in each language:

Programming Language	Time Taken (Seconds)
C	X seconds
C++	Y seconds
Java	Z seconds
Python	A seconds
Go	B seconds
C#	C seconds
JavaScript (Node.js)	D seconds

Conclusion

The results demonstrate the performance differences between these languages. C and C++ are typically the fastest, followed by Go and C#. Java and JavaScript also perform well, while Python tends to be slower due to its interpreted nature. The choice of programming language can have a significant impact on performance, especially for tasks involving large-scale computations.

We hope this comparison was insightful! Stay tuned for more programming insights and performance analysis.

Performance Comparison of Programming Languages: Counting from 1 to 1 Billion

Comments