Hans Spaans

One billion nested loop iterations

2025-09-09T10:00:00+00:00

A few days ago I was reading a post on LinkedIn about a performance comparison between Python and other languages. The author made a benchmark with a nested loop of one billion iterations in both languages and concluded that C and Rust was much faster than Python. As I was curious about this claim, I decided to replicate the benchmark myself and see if I could achieve similar results and how much of this post was true.

Note

This benchmark is mostly done for fun and educational purposes on GitHub Codespaces.

As no code was provided in the post, all the code had to be created from scratch. The benchmark consists of a nested loop where the outer loop runs 100,000 times and the inner loop runs 10,000 times, resulting in a total of 1 billion iterations (10^5 * 10^4 = 10^9). A counter variable is incremented in each iteration to ensure that the loops are not optimized away by the compiler or interpreter. And generating the source code for different languages was an ideal task for Google Gemini with some hints from GitHub Copilot.

Warning

The following code snippets are for educational purposes only and may not represent best practices for performance benchmarking or to have the most efficient code in each language.

Python Benchmark

Here is the Python code I used for the benchmark:

Python code for one billion nested loop iterations

import time

def nested_loop_counter():
    """
    Performs 1 billion nested loop iterations and measures the execution time.

    The outer loop runs 100,000 times and the inner loop runs 10,000 times,
    resulting in a total of 1,000,000,000 iterations (10^5 * 10^4 = 10^9).
    """
    print("Starting the nested loop counter...")
    start_time = time.time()

    # Initialize a counter variable
    count = 0

    # Outer loop runs 100,000 times
    for i in range(100000):
        # Inner loop runs 10,000 times
        for j in range(10000):
            count += 1

    end_time = time.time()

    # Calculate the total execution time
    elapsed_time = end_time - start_time

    print("\n--- Execution Finished ---")
    print(f"Total iterations: {count}")
    print(f"Time taken: {elapsed_time:.2f} seconds")
    print("------------------------")

# Run the program
if __name__ == "__main__":
    nested_loop_counter()

The results of the Python benchmark were as follows:

Python benchmark execution output

$ python3 onebillion.py
Starting the nested loop counter...

--- Execution Finished ---
Total iterations: 1000000000
Time taken: 22.81 seconds
------------------------

And with 22.81 seconds, Python was indeed not the fastest language for this benchmark. As a comparison, I also ran the code with PyPy, which is an alternative implementation of Python that often provides better performance for long-running tasks. The results with PyPy were significantly better:

PyPy benchmark execution output

$ pypy3 onebillion.py
Starting the nested loop counter...

--- Execution Finished ---
Total iterations: 1000000000
Time taken: 0.51 seconds
------------------------

Java Benchmark

Here is the equivalent Java code for the benchmark:

Java code for one billion nested loop iterations

import java.lang.System;

public class nested_loop_counter {

    public static void main(String[] args) {

        // Use 'long' for the counter and loop variables to ensure they can
        // handle a very large number of iterations without overflowing.
        long count = 0;

        System.out.println("Starting the nested loop counter...");

        // Start the timer using nanoseconds for high precision
        long startTime = System.nanoTime();

        // The outer loop runs 100,000 times
        for (long i = 0; i < 100000; i++) {
            // The inner loop runs 10,000 times
            for (long j = 0; j < 10000; j++) {
                count++;
            }
        }

        // Stop the timer
        long endTime = System.nanoTime();

        // Calculate the elapsed time in seconds
        double elapsedTimeInSeconds = (endTime - startTime) / 1_000_000_000.0;

        System.out.println("\n--- Execution Finished ---");
        System.out.println("Total iterations: " + count);
        System.out.printf("Time taken: %.2f seconds\n", elapsedTimeInSeconds);
        System.out.println("------------------------");
    }
}

Luckily, modern Java development environments and build tools allow developers to compile their code more easily for development purposes. The results of the Java benchmark were as follows:

Output of Java benchmark for one billion nested loop iterations

$ java onebillion.java
Starting the nested loop counter...

--- Execution Finished ---
Total iterations: 1000000000
Time taken: 0.23 seconds
------------------------

The results show that Java is indeed faster than Python for this benchmark, completing the task in just 0.23 seconds. Overall quite impressive to see how much the JVM has improved over the years.

Golang Benchmark

Here is the equivalent Go code for the benchmark:

Go code for one billion nested loop iterations

package main

import (
        "fmt"
        "time"
)

func main() {
        // Use int64 for the counter to handle the large number of iterations.
        var count int64 = 0

        fmt.Println("Starting the nested loop counter...")

        // Start the timer
        start := time.Now()

        // The outer loop runs 100,000 times
        for i := 0; i < 100000; i++ {
                // The inner loop runs 10,000 times
                for j := 0; j < 10000; j++ {
                        count++
                }
        }

        // Stop the timer
        elapsed := time.Since(start)

        fmt.Println("\n--- Execution Finished ---")
        fmt.Printf("Total iterations: %d\n", count)
        fmt.Printf("Time taken: %s\n", elapsed)
        fmt.Println("------------------------")
}

Like Java, Go also has a built-in compiler as part of the Go toolchain. The results of the Go benchmark were as follows:

Output of Go benchmark for one billion nested loop iterations

$ go run onebillion.go
Starting the nested loop counter...

--- Execution Finished ---
Total iterations: 1000000000
Time taken: 130.028666ms
------------------------

The results show that Go is also quite fast for this benchmark, completing the task in just 130 milliseconds. This performance is comparable to Java, demonstrating Go’s efficiency in handling such tasks.

Perl Benchmark

Here is the equivalent Perl code for the benchmark:

Perl code for one billion nested loop iterations

use strict;
use warnings;
use Time::HiRes qw(time);

# Use a scalar variable for the counter. Perl handles large numbers automatically.
my $count = 0;

print "Starting the nested loop counter...\n";

# Start the timer
my $start_time = time();

# Outer loop runs 100,000 times
for (my $i = 0; $i < 100000; $i++) {
    # Inner loop runs 10,000 times
    for (my $j = 0; $j < 10000; $j++) {
        $count++;
    }
}

# Stop the timer
my $end_time = time();

# Calculate the total execution time
my $elapsed_time = $end_time - $start_time;

print "\n--- Execution Finished ---\n";
print "Total iterations: $count\n";
printf "Time taken: %.2f seconds\n", $elapsed_time;
print "------------------------\n";

For Perl, the interpreter is usually included in the standard installation, but the HiRes module is required for high-resolution timing and needs to be installed separately. The results of the Perl benchmark were as follows:

Output of Perl benchmark for one billion nested loop iterations

$ perl onebillion.pl
Starting the nested loop counter...

--- Execution Finished ---
Total iterations: 1000000000
Time taken: 15.24 seconds
------------------------

The results show that Perl is indeed faster than Python for this benchmark, completing the task in just 15.24 seconds. While this is faster than Python, it is still slower than both Java and Go.

Clang Benchmark

Here is the equivalent C code for the benchmark:

C code for one billion nested loop iterations

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

int main() {
    // Use long long for the counter to avoid integer overflow, as 1 billion
    // exceeds the maximum value of a standard int on many systems.
    long long count = 0;

    printf("Starting the nested loop counter...\n");

    // Start the timer
    clock_t start_time = clock();

    // Outer loop runs 100,000 times
    for (long long i = 0; i < 100000; i++) {
        // Inner loop runs 10,000 times
        for (long long j = 0; j < 10000; j++) {
            count++;
        }
    }

    // Stop the timer
    clock_t end_time = clock();

    // Calculate the total execution time in seconds
    double elapsed_time = (double)(end_time - start_time) / CLOCKS_PER_SEC;

    printf("\n--- Execution Finished ---\n");
    printf("Total iterations: %lld\n", count);
    printf("Time taken: %.2f seconds\n", elapsed_time);
    printf("------------------------\n");

    return 0;
}

For C, the GCC compiler is commonly used and is part of the GNU Compiler Collection. The results of the C benchmark were as follows without any optimizations:

Output of C benchmark compiled without optimizations

$ gcc onebillion.c
$ ./a.out
Starting the nested loop counter...

--- Execution Finished ---
Total iterations: 1000000000
Time taken: 0.40 seconds
------------------------

But with optimizations enabled using the -O2 or -O3 flag, the performance improved significantly:

C benchmark output with GCC -O3 optimizations enabled

$ gcc -O3 onebillion.c
$ ./a.out
Starting the nested loop counter...

--- Execution Finished ---
Total iterations: 1000000000
Time taken: 0.00 seconds
------------------------

Maybe a bit too fast to be true, but the compiler optimizations really make a big difference in performance for this benchmark. And secondly the resolution of the timer is not high enough to measure the time accurately. So the actual time is likely a few milliseconds, but it is reported as 0.00 seconds due to rounding.

Rust Benchmark

Here is the equivalent Rust code for the benchmark:

Rust code for one billion nested loop iterations

use std::time::Instant;

fn main() {
    // Use u64 for the counter and loop variables to ensure they can handle
    // a very large number of iterations without overflow.
    let mut count: u64 = 0;

    println!("Starting the nested loop counter...");

    // Start the timer
    let start_time = Instant::now();

    // Outer loop runs 100,000 times
    for i in 0..100000 {
        // Inner loop runs 10,000 times
        for j in 0..10000 {
            count += 1;
        }
    }

    // Stop the timer and calculate the duration
    let end_time = Instant::now();
    let elapsed_time = end_time.duration_since(start_time);

    println!("\n--- Execution Finished ---");
    println!("Total iterations: {}", count);
    println!("Time taken: {:.2?} seconds", elapsed_time);
    println!("------------------------");
}

Lets see how Rust performs in this benchmark. The results of the Rust benchmark were as follows without any optimizations:

Output of Rust benchmark (no optimizations)

$ rustc onebillion.rs
warning: unused variable: `i`
--> onebillion.rs:14:9
|
14 |     for i in 0..100000 {
|         ^ help: if this is intentional, prefix it with an underscore: `_i`
|
= note: `#[warn(unused_variables)]` on by default

warning: unused variable: `j`
--> onebillion.rs:16:13
|
16 |         for j in 0..10000 {
|             ^ help: if this is intentional, prefix it with an underscore: `_j`

warning: 2 warnings emitted

$ ./onebillion
Starting the nested loop counter...

--- Execution Finished ---
Total iterations: 1000000000
Time taken: 2.24s seconds
------------------------

If we ignore the warnings about unused variables, Rust performs quite well, completing the task in just 2.24 seconds. However, with optimizations enabled using the -O flag, the performance improved significantly:

Rust benchmark output with optimizations (-O flag)

$ rustc -O onebillion.rs
warning: unused variable: `i`
--> onebillion.rs:14:9
|
14 |     for i in 0..100000 {
|         ^ help: if this is intentional, prefix it with an underscore: `_i`
|
= note: `#[warn(unused_variables)]` on by default

warning: unused variable: `j`
--> onebillion.rs:16:13
|
16 |         for j in 0..10000 {
|             ^ help: if this is intentional, prefix it with an underscore: `_j`

warning: 2 warnings emitted

$ ./onebillion
Starting the nested loop counter...

--- Execution Finished ---
Total iterations: 1000000000
Time taken: 154.00ns seconds
------------------------

And the results show that with optimizations, Rust can complete the task in just 154 nanoseconds. This performance is comparable to C with optimizations, demonstrating Rust’s efficiency in handling such tasks.

But lets fix the warnings by prefixing the unused variables with an underscore as Gemini wasn’t aware of this:

Rust benchmark output with optimizations and fixed warnings

$ rustc -O onebillion.rs
$ ./onebillion
Starting the nested loop counter...

--- Execution Finished ---
Total iterations: 1000000000
Time taken: 66.00ns seconds
------------------------

This time the performance improved even further, completing the task in just 66 nanoseconds. This shows that addressing compiler warnings can lead to better optimizations and improved performance.

Conclusion about performance

After running the benchmarks in different languages, the results were as followed: Don’t take these numbers too seriously as they can vary based on the system, compiler/interpreter versions, and other factors. But they do give a general idea of the performance differences between the languages for this specific task. And don’t believe everything you read on LinkedIn.

Raw processing performance is only one aspect of a programming language. Other factors like developer productivity, ecosystem, libraries, community support, and specific use cases also play a significant role in choosing the right language for a project. But marking a language as slow or fast based on one benchmark is not a good idea as it doesn’t take into account the full context of software development.

Time to contain Perl?

2025-09-06T10:00:00+00:00

In the world of software development, the choice of programming languages can significantly impact the maintainability and longevity of a project. Perl, once a dominant language for web development and system administration, has seen a decline in popularity over the years. As we look towards the future, it’s worth considering whether it’s time to contain Perl within our projects.

In this context, “containing” Perl refers to stopping the use of Perl for new development and instead isolating existing Perl code within specific modules or services used within an enterprise. This approach allows us to manage the risks associated with legacy technologies while still leveraging their strengths where appropriate. For personal projects, the reasoning is similar, but often more pragmatic as the impact of legacy code is less critical than in an enterprise setting.

The Rise and Fall of Perl

Perl was once hailed as the “duct tape of the internet,” thanks to its flexibility and powerful text-processing capabilities. It was widely used for CGI scripting, system administration, and even web application development. However, with the advent of newer languages like Python, Ruby, and JavaScript, Perl’s popularity has waned. These newer languages offer more modern syntax, better libraries, and a more active community, making them more appealing to developers.

Especially with the rise of web frameworks like Django (Python), Ruby on Rails (Ruby), and Node.js (JavaScript), developers found more efficient ways to build web applications. Maybe also the PHP ecosystem with frameworks like Laravel and Symfony played a role in this shift as it was easier to learn for many web developers and manage than mod_perl or CGI scripts.

The future of Perl looks uncertain as Perl 6 was announced in 2000 and later rebranded to Raku and has not seen widespread adoption. In 2020, Perl 7 was announced, aiming to modernize the language and make it more accessible to new developers. In 2021, this plan was slightly adjusted to keep Perl 5 in long-term maintenance mode with only important security and bug fixes coming to it. However, the impact of Perl 7 remains to be seen as it will only be released when enough features are ready and stable.

The Current Landscape

As we assess the future of Perl, it’s essential to consider the current landscape of software development. Many organizations are adopting microservices architectures, containerization, and cloud-native technologies. These trends emphasize the need for modular, maintainable code that can evolve independently.

In this context, the case for containing Perl code becomes more compelling. By isolating Perl components, we can better manage their lifecycle and reduce the impact of their limitations on the overall system. And the rise of DevOps practices and CI/CD pipelines also emphasizes the need for maintainable and testable code, which can be challenging with legacy Perl codebases.

Here are some key considerations for containing Perl in modern software development:

Modularity: Break down Perl applications into smaller, manageable components that can be developed, tested, and deployed independently. This aligns with microservices architectures and promotes better maintainability.
Containerization: Use containerization technologies like Docker to encapsulate Perl applications and their dependencies. This can simplify deployment and ensure consistency across different environments.
Automated Testing: Invest in automated testing frameworks and practices to improve the reliability of Perl code. This is crucial for maintaining code quality and facilitating continuous integration.
Documentation: Improve documentation for Perl codebases to make them more accessible to new developers. This can help mitigate the challenges posed by a shrinking talent pool.
Hiring and Training: Consider the availability of skilled Perl developers when planning projects. Investing in training for existing team members can help bridge the gap.

While most of these considerations are technology driven, the final one about recruitment and training is more business driven. The availability of skilled Perl developers is decreasing as newer generations of developers are less likely to learn Perl. This can lead to challenges in maintaining and extending Perl codebases, making it essential for organizations to consider the long-term implications of their technology choices.

The Challenges of Perl

Despite its strengths, Perl has several challenges that have contributed to its decline:

Readability: Perl’s syntax can be complex and difficult to read, especially for those who are not familiar with it. This can lead to maintenance challenges as codebases grow and evolve.
Community Support: The Perl community has shrunk over the years, leading to fewer resources, libraries, and frameworks being developed and maintained.
Performance: While Perl is powerful, it may not always be the most efficient choice for modern applications, especially when compared to languages optimized for specific tasks.
Talent Pool: As newer generations of developers enter the workforce, many are less familiar with Perl, making it harder to find skilled developers to maintain and extend Perl codebases.
Ecosystem: The ecosystem around Perl has not kept pace with modern development practices, making it less attractive for new projects.

While commercial support for Perl exists, it is not as widespread as for other languages like Java, Python, or JavaScript. This can make it challenging for organizations to find the necessary support and resources to manage their Perl code effectively. This also affects the availability of training and development resources for teams working with Perl, as new developers may be difficult to find and hire.

The Case for Containment

In light of these challenges, containing Perl code within specific modules or services can offer several benefits:

Maintainability: As projects grow and evolve, maintaining code written in Perl can become challenging, especially if the original developers are no longer available. Containing Perl code within specific modules or services can help isolate it from the rest of the codebase, making it easier to manage.
Interoperability: By containing Perl code, we can create clear interfaces between different parts of the system. This allows for easier integration with other languages and technologies, facilitating a more modular architecture.
Legacy Systems: Many organizations still rely on legacy systems built with Perl. Containing these systems can help ensure they continue to function while allowing for gradual migration to more modern technologies.
Security: Containing Perl code can also help mitigate security risks associated with outdated libraries and dependencies. By isolating Perl components, we can better manage updates and patches.
Team Dynamics: As development teams evolve, the skill sets of team members may change. Containing Perl code can help ensure that new team members can work effectively without needing to learn an older language.

While the Perl interpreter is still actively maintained, the libraries and frameworks around it are not as actively developed as those for other languages. This can lead to challenges in finding up-to-date resources and tools for working with Perl. Other languages like Python have even begun to drop built-in modules as they are no longer maintained or considered best practice. This can lead to security vulnerabilities and compatibility issues if not managed properly or running outdated versions.

Challenges of Containment

Managing and containing Perl code is not without its challenges like any legacy technology. Some of the key challenges include:

Technical Debt: Containing Perl code may not eliminate the technical debt associated with it. Legacy code can still be difficult to work with, and simply isolating it may not address underlying issues.
Integration Complexity: As we contain Perl code, we must also consider how it will interact with other parts of the system. This can introduce additional complexity and potential points of failure.
Resource Allocation: Containing Perl code may require dedicated resources for maintenance and support. Organizations must weigh the costs and benefits of this approach.

Maintaining legacy systems is done in many organizations on a minimal budget and often with limited resources. This can make it challenging to allocate the necessary time and effort to properly contain and manage Perl code. A clear strategy and prioritization are essential to ensure that containment efforts are effective and sustainable as part of a broader IT and business strategy. Especially the business side must be on board as well to allocate budget and resources, but also accept potential risks and limitations like no new features or performance improvements in the contained Perl parts as long as the transition is not completed.

The Case for keeping Perl

While the trend is to move away from Perl, there are still valid reasons for keeping Perl code in certain situations:

Familiarity: Many developers have extensive experience with Perl, and re-training them on a new language can be time-consuming and costly. Keeping Perl code allows organizations to leverage existing expertise.
Proven Solutions: Perl has a rich ecosystem of libraries and frameworks that have been battle-tested over the years. These solutions can be valuable assets for organizations that continue to use Perl.
Rapid Prototyping: Perl’s flexibility and expressiveness make it an excellent choice for rapid prototyping and scripting tasks. Keeping Perl code can enable teams to quickly iterate on ideas without the overhead of more rigid languages.
Niche Applications: In certain domains, such as bioinformatics and text processing, Perl remains a popular choice due to its powerful capabilities. Keeping Perl code in these niche areas can be beneficial.
Legacy Systems: Many organizations have significant investments in Perl codebases that would be costly and time-consuming to replace. In such cases, it may be more practical to maintain and contain the existing Perl code rather than attempting a complete rewrite.

In some cases, the cost and effort required to migrate away from Perl may outweigh the benefits. Organizations must carefully evaluate their specific circumstances and make informed decisions about whether to keep or contain Perl code. If the Perl code is stable, well-maintained, and continues to meet the needs of the organization, there may be little incentive to replace it if the risks and costs are too high. We see the same with COBOL in many financial institutions and mainframe systems that are still in use today where the costs to run today are lower than a complete rewrite or migration.

Conclusion about containing Perl

In conclusion, containing Perl code within our projects presents both opportunities and challenges. While it can improve maintainability, interoperability, and security, we must also address the technical debt and integration complexities that come with it. By carefully considering these factors, we can make informed decisions about the role of Perl in our software development efforts.

Ultimately, the decision to contain Perl should be based on the specific needs and context of each project. As we move forward in the ever-evolving landscape of software development, it’s crucial to remain adaptable and open to change, ensuring that our technology choices align with our long-term goals. But from an enterprise architecture perspective, it is indeed time to contain Perl as part of a broader strategy to manage legacy technologies and embrace modern development practices.

The key is to have a clear strategy, allocate the necessary resources, and involve all stakeholders in the decision-making process. By doing so, we can ensure that our software development efforts remain robust, flexible, and aligned with our long-term objectives. This isn’t just about Perl; it’s about how we maintain and evolve our entire technology stack in a rapidly changing world. We must be proactive in addressing the challenges of legacy technologies while embracing the opportunities presented by modern development practices.

As closing note, it’s important to remember that technology choices within organizations should always be driven by business needs and goals. While technical considerations are crucial, they must be balanced with the broader context of the organization’s strategy and objectives. By taking a holistic approach to technology management, we can ensure that our software development efforts contribute to the overall success and sustainability of the organization.

Reading books for work and pleasure

2023-06-01T00:00:00+00:00

In my childhood I basically lived in the library for comics and what can be considered now as business kind of books. The storytelling books never attracted me to seek them out actively and even today most are recommendations from others or an algorithm telling me that I may like those as well.

It wasn’t until I started to join the workforce that storytelling books really took off as they became available as usenet download and I could read them on my commute to work, or better said listen to them during my commute as they were audiobook downloads. It was a solid 10 to 15 hours every week listening to an audiobook instead of the radio and wasting my hours.

As YouTuber CGP Grey said in an earlier episode of the Cortex Podcast that this is a method to tell your brain about all kinds of situations in the hope it will remember it when the time is there. If it is true time will tell, but in a lot of cases it will also shape your view on certain subjects as you gain more knowledge.

With this in mind I still buy audiobooks and physical books to gain more knowledge and insight. I even have my wishlist filled with some retailers to buy them when there is a discount and you don’t want to break the bank. Another option are public libraries which are great for storybooks and business books that have earned their place. For more recent IT books buying may be the better option unless you can wait and you know your local library will have them.

Another benefit of buying those books is that you can sit down and read them, but also to make notes for later and easily go back. Something that doesn’t work for me correctly with just a book in PDF or ePub format, but Google Play Books makes it easier nowaday for you to make remarks and highlight sections that also are visible on Google Drive.

Especially the changes that are coming with cloud, big data, and zero-trust require that we start thinking differently about the whole IT-landscape. Taking your time to explore and think about it takes time and I would recommend taking that time now that you have it. It also gives you the freedom to take your chances with another position or company, or even start your own. Always keep exploring, reading, and learning.

Why start blogging

2023-05-01T00:00:00+00:00

Learning new skills and improving existing skills was and still is important, and especially communication and planning skills are in higher demand than ever. These skills aren’t learned and mastered overnights which also came to light in conversations with different software and infrastructure engineers as they were looking on where and how to make their next step in their career.

One option is to make it part of a development plan to get training and coaching, but this requires that you already have a clear goal. A second option is to start developing yourself to the point where you know what you want or others see a path for you. This seems to be a daunting task but in the current day and age may be easier than ever before.

Inexpensive courses on any topic can be found on known video streaming sites for free or for about 10 USD on some online-education sites. These courses can teach you anything from coding in Python or Java to become a better technical writer or making presentations to look fantastic. The online thing these courses can’t teach you is to master the course material as that takes time and some say up to 10.000 hours, but at least you should apply the knowledge to really understand it.

Starting a blog can help you with this as it teaches you so many things like writing understandable articles for strangers to read and finding out what really works in the end. If done correctly and long enough this can also help to become an authority in your field and help others to make better decisions. While blogging has its ups and downs over the years, a lot of useful blogs exist from how to do data governance, running your business, optimizing code, or explaining concepts in a simple form.

While I’m already writing for other sites, I’m following my own advice to blog as well from a more personal point of view. The other writings are especially more technical instead of telling a story. Lets see how this journey goes and if I can keep up with my own advice but also it inspires others to join this journey on better expressing yourself in writing.

First blog post

2023-04-01T00:00:00+00:00

This is my first blog post to test Sphinx with Ablog. There isn’t a lot here right now, come check back later.