For example, you might know that C++ is faster than Python. So why is this the case?

Well, C++ is a language that uses a compiler, not to mention it is a much lower-level programming language than Python. That is to say, C++ provides much less abstraction from a computer's instruction set and architecture.

On the other hand, Python is an interpretated language, which just means that every line of the program is evaluated as the program is running.

But, how much faster IS C++ compared to Python? In this article you will see 3 algorithms and how they perform in C++ and Python. These algorithms are from "Data Structures and Algorithms Using C++" by Michael T. Goodrich.

Note: The computer I ran these tests on was an Acer Swift 3. The CPU was a Ryzen 7 7500U with Radeon Graphics 1.80Gz. Along with 8GB of RAM, running Windows 10 Home.

You will be looking at these algorithms and their Big O Notation. Big O is a mathematical way of expressing the worst-case scenario of the time or space complexity of an algorithm.

The time complexity is the amount of time it takes for an algorithm to run, while the space complexity is the amount of space (memory) an algorithm takes up. Here is a graph to help explain Big O:

Big O Cheat Sheet – Time Complexity Chart (freecodecamp.org)

From now on, I'll refer to each algorithm as running with a certain time complexity.

For example, if I say an algorithm runs with a O(n) time complexity, this means that as the input grows, the time it takes for an algorithm to run is linear. If I say it runs with O(n^2) time complexity, this means that as the input grows, the time it takes for an algorithm to run is quadratic.

Performance of the 1st Algorithm:

Algorithm Ex1(A):
    Input: An array "A" storing n >= 1 integers.
    Output: The sum of the elements in A.

    s = A[0]
    for i = 1 to n - 1 do:
        s = s + A[i]
    return s

In Python, we can express this algorithm as:

def ex1(A):
    sum = A[0]
    for i in A:
        sum = sum + A[i]
    return sum

If you use inputs up to about 5 million you will see that this algorithm takes about 4 seconds to run with that large of an input.

Performance of the 1st Algorithm

Then you can compare this algorithm in C++, like this:

double ex1(double A[], size_t n)
{
    double sum = A[0];
    for(size_t i = 0; i < n; i++)
    {
        s = s + A[i];
    }
    return sum;
}

You may be wondering, what is size_t? size_t is an "unsigned integer". This just means that this variable does not have a sign. Which also just means that this variable is not negative.

In C++, we use size_t to keep track of positions in an array, since those positions cannot be negative (at least in C++, since in Python we can have negative indexes).

Now let's take a look at the running time of the first algorithm:

Performance of the 1st Algorithm in C++

As you can see from these two charts, the time complexity seems to be linear. This means that the time complexity of this algorithm is O(n) – as the input size for A grows, the time it takes for this algorithm to run grows linearly.

But it is interesting to notice that for very large inputs of 5 million, C++ does not even break the 1 second mark. Whereas Python breaks the 3-4 second mark for inputs at about 5 million. Let's move on to our next algorithm.

Performance of the 2nd Algorithm:

Algorithm Ex3(A):
    Input: An array "A" storing n >= 1 integers.
    Output: The sum of the prefix sums in A.
    s = 0
    for i = 0 to n - 1 do:
        s = s + A[0]
        for j = 1 to i do:
            s = s + A[j]
    return s

Here, you can see that this algorithm has two for-loops. So, moving forward this is something to acknowledge when analyzing the time complexity.

In Python, you can express this algorithm like this:

def ex3(A):
    sum = 0
    for i in range(len(A)):
        sum = sum + A[i]
        for j in range(1, i):
            sum = sum + A[j]
    return sum

Let's also use inputs all the way up to 70,000. Then we will record the times and chart the data like so:

Time Performance of the 2nd Algorithm in Python

These results are much different from our previous charts from algorithm 1. Something to point out is that with an input of 70,000, this algorithm takes a whopping 91 seconds in Python. Thats a long time!

Also, when I tried to run inputs higher than 70,000, my computer started to become unresponsive. Yikes.

Let's take a look at this algorithm in C++:

double ex3(double A[], size_t n)
{
    double s = 0;
    for(size_t i = 0; i < n; i++)
    {
        s = s + A[i];
        for(size_t j = 1; j < i; j++)
        {
            s = s + A[j];
        }
    }
    return s;
}

For the C++ code I was able to increase the input size to ~90,000.

Time Performance of the 2nd Algorithm in C++

For an input size of 70,000 this algorithm takes ~4 seconds to run in C++. That difference is huge. Not to mention, I was able to use inputs that were about ~90,000 elements in size for C++, with it not even breaking past the 10 second mark.

Also, we can see that the curve is not as smooth as the Python graph. This could be due to some other processes running in the background (since I'm running on Windows 10) or some other reason.

Also, we can classify the time complexity of this algorithm as O(n^2), which just means that the time complexity for this algorithm is quadratic.

Let's move on to the last algorithm.

Performance of the 3rd Algorithm:

Algorithm Ex5(A, B):
    Input: Arrays "A" and "B" each storing n >= 1 integers.
    Output: The number of elements in B equal to the sum of
            prefix sums in A.
    c = 0
    for i = 0 to n - 1 do:
        s = 0
        for j = 0 to n - 1 do:
            s = s + A[0]
            for k = 1 to j do:
                s = s + A[k]
            if B[i] == s then:
                c = c + 1
    return c

Let's take a look at this code in Python:

def ex3(A, B):
    c = 0
    for i in range(len(A)):
        s = 0
        for j in range(len(A)):
            s = s + A[0]
            for k in range(1, j):
                s = s + A[k]
            if B[i] == s:
                c = c + 1
    return c

Now, let's analyze the timings:

Time Performance of the 3rd Algorithm in Python

Woah, what's going on here? We can see that as our inputs starts to increase, the rate at which the algorithm runs also starts to increase, but it is increasing at a drastic rate.

In this case, we can see with an input size of 3500 that it takes 761 seconds for this algorithm to run in Python. You may be asking, "Did you actually sit through all 761 seconds?", the answer is yes. Yes, I did.

Now let's take a look at the C++ code:

double ex5(double A[], double B[], size_t n)
{
    double c = 0;
    for(size_t i = 0; i < n; i++)
    {
        double s = 0;
        for(size_t j = 0; j < n; i++)
        {
            s = s + A[0]
            for(size_t k = 1; k < j; k++)
            {
                s = s + A[k];
            }
            if(B[i] == s)
            {
                c = c + 1
            }
        }
    }
    return c;
}

Let's take a look at the graph.

Time Performance of the 3rd Algorithm in C++

Similar to the second algorithm, it is interesting to see that the curve is not as smooth as the Python graph.

Also, we can see that we can go well above an input size of 3500. My computer started acting up once I pushed the input size past 10,000 for C++. Not to mention, with an input size of 10,000 the algorithm averaged about 544-545 seconds.

We can classify this algorithm as having a time complexity of O(n!). Which just means that this algorithm is factorial, which runs very slowly.

Wrapping Up

I hope you found the differences of running times between Python and C++ just as fascinating as I have.

Also, just because Python runs slower than C++ for every algorithm does not mean that C++ is the "better" language. Both of these languages have their own purposes for the type of software you are trying to create.

C++ would be the preferred language if performance is critical. If you were programming games, operating systems, or communicating between machinery, C++ would be the better choice due to its compiled and fast nature.

Python would be preferred if you need to develop software quickly. Due to its easier learning curve, almost anyone can pick up Python and start creating software with it. Python also provides many resources for data science and machine learning.

Check out the code if you would like to try these tests on your own computer:

Cheers!

There are other environments such as the C Shell, Korn Shell, Z Shell, and even the Fish Shell. All of these different shell environments have their own pros and cons, and you should consider them before you choose one to use on your own system.

In this article, I'll go over a few popular shells along with their main features to help you pick one.

The Bash Shell

The Bash Shell (or the Bourne Again Shell) is a UNIX shell and command language. It was written by Brain Fox for the GNU Project as a free software replacement for the Bourne Shell (sh).

Bash was first released in 1989, and for most Linux distributions it's the default Shell environment. Other distros, like Kali Linux, use the Z Shell as their default shell.

Bash is one of the first programs that Linus Torvalds (the creator of Linux) ported to Linux.

Image Source

Something you should not get confused about is that Bash is also a programming language. So it's a "Shell", but you can also program behavior in Bash. For example:

#!/bin/bash
echo "Hello World"

Key points about Bash

• Most users use Bash, since it is the default shell environment on most systems
• Bash does not have an inline wildcard expression. A wildcard expression is when you would want to search for patterns in your Shell, similar to Regex. The three main wildcards are *, ?, and [].
• You can't automatically change the directory name
• # is treated as a comment in scripting
• It has shopt settings
• Prompt has backslash escapes
• User configuration settings are in .bashrc

The Z Shell

The Z Shell, or Zsh is also a UNIX shell that is very similar to Bash. You can also script and use the shell as a command interpreter.

Zsh is an extension of the Bourne shell with a lot of improvements. Zsh was released in 1990 by Paul Falstad, and it has some features that Bash, Korn Shell, and C Shell share.

macOS by default uses the Zsh Shell.

Image Source

Key points about Zsh

• Comes with autocompletion when using the terminal. So when you press Tab ↹ in order to autocomplete whatever command you want to run, not only does it autocomplete for you but will bring down a drop-down of all the other possible files and directories:

• Supports inline wildcard expressions
• Much more configurable than Bash
• Supports plugins and themes. Here's a list of plugins available for Zsh.

There are also frameworks built around the Z Shell. One of the most popular ones is Oh My Zsh, which is a community driven, open-source framework for managing Zsh configuration. (I use Oh My Zsh 😄)

Image Source

Zsh and Oh My Zsh are similar but not the same exact things. To reiterate, Oh My Zsh is a way of managing your Zsh configurations, it is not the Shell itself.

The Fish Shell

Fish is a UNIX shell environment with an emphasis on interactivity and usability. Unlike Zsh, Fish aims to give the user interactivity by default instead of trusting the user to implement their own configuration.

It was created by Axel Liljencrantz in 2005. Fish is considered to be an "exotic shell" due to the fact that it does not comply to the POSIX shell standards. [[Source](https://en.wikipedia.org/wiki/Fish_(Unix_shell)]

Image Source

Key points about Fish

• Fish has "search as you type" automatic suggestions based on your command history and the directory you are in. Similar to Bash's history search, Fish Shell's search history is always turned on. That way the user will be able to get interactive feedback when working in their terminal.

Image Source

• Fish also prefers features as commands rather than syntax. This makes features visible in terms of commands with options and help texts
• Since Fish by default comes with a lot of configurations already set, it is believed to be more beginner friendly than other sh options like Zsh.
• Fish's scripting language is different than Zsh and Bash. Zsh uses more aliases whereas Fish avoids using aliases in the scripting language.

If you were to just make scripts using basic commands such as, cd, cp, vim, ssh, and so on, you would not notice any difference in the way Fish and Bash's scripting languages work.

One of the biggest differences is when you try capturing output from a command. In Bash you may be used to this:

todays_date=$(date)
echo "Todays date is $todays_date"

Todays Date is Tue Dec 13 15:29:28 CST 2022

Whereas in Fish, capturing output works differently. The equivalent for Fish in scripting would look like this:

set date (date)
echo "Todays Date $date"

todays date is Tue Dec 13 21:35:03 UTC 2022

Conclusion

Bash, Z Shell, and Fish Shell all have their merits, along with some similarities. You can use each of them effectively in your work environment now that you know a bit more about them.

If you want something more configurable, you could use Zsh (or even install Oh My Zsh). If you want more of an interactive terminal experience without a lot of configuration, you could use Fish Shell. If you want the classic feel, you can just keep Bash.

It all really comes down to your preferences as a developer - so just choose the shell that works best for you.

Hope this helped you! Thank you for reading 🐚🐚🐚

But for those running Linux, if that includes a dual boot, virtual box, or even WSL2, you could use a useful Linux command to inspect and look at all the current processes going on in your operating system.

MacOS Activity Monitor

Windows Task Manager

What is the Linux Equivalent?

The top (table of processes) command in Linux will display all the system processes. If you were to try this command in your terminal, you would see this:

Thats pretty neat – the top program shows a dynamic list of all the running processes going on in your Linux system.

Usually, this command shows a summary of the information on your system that's currently being run/managed by the Linux kernel.

To leave top press q on your keyboard to exit the interactive shell.

What do the columns mean?

• PID: Shows the task's unique process ids.
• USER: Shows which user is running what task

For example, you see "root" and "brandgrim". Root is, well, the root of the system running that process, whereas "brandgrim" (me!) is the user running that process.

• PR: This number shows the process priority – the lower the number is, the higher priority. (Makes sense intuitively, right?)
• VIRT: The total virtual memory used by the task
• RES: How much RAM the process is actually using, measured in KB
• SHR: This number represents the Shared Memory size used by a specific task
• %CPU: Represents the CPU usage
• %MEM: Represents the Memory usage
• +TIME: Depicts the total CPU time that the task has used since the task started
• COMMAND: The name of the command that actually started the process

When you are in the interactive shell of top you can press h to bring up the Summary of Less Commands which is a list of all the commands top has to offer.

Showing the "Summary of Less Commands" in top

Useful Flags and Commands

top has so many unique flags and commands it may seem overwhelming to know which one to use, although there are some flags that are useful right off the bat.

How to Filter by User

The -u flag specifies which processes should be listed depending on what user you specify.

For example, we saw that under the USER column there was "root" and "brandgrim", so if we were to try this:

top -u root

we would see the following:

Which lists out the processes that are being run under the "root" user. If we were to try this command, on the other hand:

top -u brandgrim

We'd get the following (which shows processes being run under the "brandgrim" user):

How to Change the Refresh Interval

By default, the screen refresh interval for top is set to 3.0 seconds. If you would like to increase the interval or decrease it, you can press d while you are in the top interactive shell in order to set a desired time.

Showing how to change the refresh interval

How to Sort Processes by CPU Utilization

In order to sort all your Linux processes by how much CPU they use, you would need to press the SHIFT + P keys in order to sort them in top. Now you know what was hogging up your CPU – that pesky little while loop that kept running infinitely!

For example, when I filter my processes when I open VSCode, here's what I see:

You can see that the CPU utilization is initially very high, although it starts to decrease as VSCode loads in all my extensions and the Intellisense.

How to Save Top Processes Inside a File

To save all the running top command results into a file, you can use these commands:

top -n 1 -b > top-processes.txt

top Alternatives

There are plenty of top alternatives, such as Htop, Vtop, Gtop, Gotop, and many more – although I won't cover all these in this article.

Htop is currently the most popular top alternative thanks to its interactive menu and the ability to scroll vertically and horizontally. Not to mention that Htop also allows you to view your processes in a tree-like structure, which is easier to visualize.

Htop (looks cool!)

Conclusion

top is an interactive shell that allows you to view all your Linux processes in a real-time view. It displays system information along with lists of processes or threads being currently used by the Linux kernel.

top comes with its own useful commands such as the -u flag and d command. There are some more mordern top alternatives like Htop which allows for a more colorful and interactive shell.

Hope this helped you! Thank you for reading :)