What easily comes to mind is to comment out all the printf statements and recompiling. But, imagine a codebase with hundreds of thousands of logs. It will get quite tedious to get rid of all the logs, and it's also easy to miss some.

Another option would be to wrap all printf statements with an ifdef. For example:

#include <stdio.h>

#define DEBUG

int main() {
#ifdef DEBUG
    printf("Hello...");
#endif
}

If DEBUG is defined, printf will be there and when it's not, the printf will not be there in the final compiled binary.

But this is also quite inefficient. Imagine having to write three lines instead of one for a simple print statement, not to mention the complication of a trivial task like printing a message. The reason that I'm telling this is that there's a better option.

What if instead of directly using printf, we create a macro to transform it into some other form, but then we use another macro to select which form that we're using? This is exactly where the optimum way to do logging lies. Here's a sample code:

#include <stdio.h>

#define DEBUG 1

#if DEBUG
    #define LOG(fmt, ...) printf(fmt "\n", ##__VA_ARGS__)
#else
    #define LOG(fmt, ...) 
#endif

int main() {
    int connection_count = 5;
    
    LOG("Server started successfully.");
    LOG("Current connections: %d", connection_count);

    return 0;
}

Notice how there's an if macro which chooses between two forms for a function we define as LOG(fmt, ...). In case DEBUG is 1, it automatically turns into printf(fmt "\n", ##__VA_ARGS__), the printf we know and love. But if it's 0, it turns into nothing. This creates a simple, efficient and clean way to enable and disable logs. You just have to write LOG(...) like you're used to and then define DEBUG as 1 or 0 to enable or disable the logging.

The keen eyed among you might worry if this might end up with unwanted instructions in your code. The thing is, modern compilers will happily compile this code without any overhead. Still don't believe me? Checkout this sample code in Compiler Explorer: https://godbolt.org/z/3c4qfvM3E.

The assembly for the case of DEBUG is 1 turns out to be:

.LC0:
        .string "Server started successfully."
.LC1:
        .string "Current connections: %d\n"
main:
        sub     rsp, 8
        mov     edi, OFFSET FLAT:.LC0
        call    puts
        mov     esi, 5
        mov     edi, OFFSET FLAT:.LC1
        xor     eax, eax
        call    printf
        xor     eax, eax
        add     rsp, 8
        ret

Try turning DEBUG to 0 and see the compilation. It will turn out to be:

main:
        xor     eax, eax
        ret

As you can see, the whole logging statements disappeared without any residual code.

Thus, we can see that this eliminates all the issues we had with the previous two methods. In fact most modern code uses this technique for logging. So make sure to use this in your next project.

This code is called the C Runtime (CRT), but don’t confuse this with the Java Runtime Environment (JRE) or the Python Runtime Environment (PRE). Unlike Java and Python code, C code directly runs on the bare-metal, but there does exist some work that needs to be done before, while and after our code runs. This is handled by the C Runtime. Let’s dive a bit deeper…

The CRT consists of four main components:

• Startup Sequence: Before our main() function even runs, the CRT performs initialization. It sets up the stack, initializes global variables, and gathers command-line arguments.

• Memory Management: It provides the logic for functions like malloc() and free(), managing the "Heap" memory, so our program can request space dynamically.

• Standard Library (libc): This is the bulk of the CRT. It includes the math functions, string manipulation tools, and input/output handlers (like printf() and scanf()).

• The Stack and Heap: The CRT manages the memory layout. The Stack handles local variables and function calls, while the Heap handles dynamic data.

Let’s dive a little bit deeper into these four tasks of the CRT.

The Startup Sequence (The "C Bootstrap")

When we click "Run," the Operating System doesn't jump straight to our int main(). It jumps to an entry point provided by the CRT (often called _start or mainCRTStartup).

• Setting the Environment: The CRT retrieves the Environment Variables (like PATH) and the Command Line Arguments from the OS. It parses them into the argc and argv parameters we see in main().

• Initialization of Statics: It clears the BSS segment (setting un-initialized global variables to zero) and copies initial values into the Data segment for variables like int x = 10;.

• Constructors: In C++ (or C with specific compiler extensions), the CRT calls "global constructors" before main starts.

• The Handshake: Finally, it calls main(). When main() finishes, the CRT takes the return value (e.g., 0) and passes it back to the OS via an exit() system call.

Memory Management (malloc and free)

The Operating System is strict; it only gives memory to programs in large "pages" (usually 4KB). If we only need 20 bytes, asking the OS directly is incredibly slow and wasteful.

• The Middleman: The CRT maintains a "pool" of memory. When we call malloc(20), the CRT looks at its pool, carves out 20 bytes, marks them as "in use," and gives you the pointer.

• Bookkeeping: The CRT keeps a hidden header just before our pointer that stores the size of the block. This is how free() knows exactly how much memory to release without us telling it the size.

• Heap Expansion: If the CRT runs out of memory in its pool, it issues a system call (like sbrk on Linux or VirtualAlloc on Windows) to ask the OS for another big chunk of RAM.

The Stack vs. The Heap

These are the two primary ways a program uses RAM, and the CRT (along with the CPU) manages the boundary between them.

• The Stack: Every time we call a function, the CRT pushes a "Frame" onto the stack. This frame holds our local variables and the "return address" (where to go when the function ends).

• The Heap: The "pile" of memory used for data that needs to live a long time or is too big for the stack (like a high-resolution image).

The Standard Library (libc)

This is the "toolbox" of C. It is a collection of pre-compiled code that performs common tasks that would be hard to write from scratch.

• System Call Wrappers: Functions like printf() or fopen() are wrappers. They take our high-level request, format it, and then perform a System Call to ask the OS kernel to actually write pixels to a screen or bits to a disk.

• Portability Layer: libc is the reason our code can run on both Windows and Linux. On Windows, printf() might call WriteFile, while on Linux, it calls write. We don't have to care; the CRT handles the translation.

• Utility Functions: These are pure logic. Things like sqrt(), strlen(), or sort(). They don't talk to the OS; they just provide optimized algorithms so we don't have to reinvent the wheel.

The Code

Curious as to how these are managed? Checkout the glibc repository to see these components in action. The _start code is under sysdeps/x86_64/start.S. This is in Assembly to facilitate the required low-level work. The memory allocation logic is under malloc/malloc.c. This is quite a complicated bit of code.

Conclusion

So what did we learn? Even C is not about compile and run. There’s a lot more happening under the hood than what we’re doing ourselves. It’s quite interesting how far these tools have come. So next time you write a new main(), think of all the work happening under the hood that keeps your code running correctly.

While this statement has a good technical value to it, this is not always the case. Switch statements are highly optimized and can outperform regular if-else statements under specific conditions. Let’s start with the basics: what is a switch statement?

int use_if_else(int value) {
    if (value == 1) {
        return 102;
    } else if (value == 2) {
        return 15;
    } else if (value == 3) {
        return 888;
    } else if (value == 4) {
        return 42;
    } else if (value == 5) {
        return 7;
    } else {
        return 0;
    }
}

You might be familiar with the above code. This is a simple example of an if-else statement. But a switch statement for the same task looks like this:

int use_switch(int value) {
    switch (value) {
        case 1:
            return 102;
        case 2:
            return 15;
        case 3:
            return 888;
        case 4:
            return 42;
        case 5:
            return 7;
        default:
            return 0;
    }
}

But how can this be more efficient than an if-else statement? The answer is actually in the underlying assembly interpretation. Let’s compare the compiled assembly representation of the two functions.

use_if_else:
        cmp     edi, 1
        je      .L3
        cmp     edi, 2
        je      .L4
        cmp     edi, 3
        je      .L5
        cmp     edi, 4
        je      .L6
        cmp     edi, 5
        mov     eax, 0
        mov     edx, 7
        cmove   eax, edx
        ret
.L3:
        mov     eax, 102
        ret
.L4:
        mov     eax, 15
        ret
.L5:
        mov     eax, 888
        ret
.L6:
        mov     eax, 42
        ret

This is how the compiled Assembly looks like for the if-else code. Below is for the switch statement. You can see it in compiler explorer: https://godbolt.org/z/K9MzEjK77

use_switch:
        cmp     edi, 5
        ja      .L2
        mov     edi, edi
        jmp     [QWORD PTR .L4[0+rdi*8]]
.L4:
        .quad   .L2
        .quad   .L8
        .quad   .L9
        .quad   .L6
        .quad   .L5
        .quad   .L3
.L8:
        mov     eax, 102
        ret
.L6:
        mov     eax, 888
        ret
.L5:
        mov     eax, 42
        ret
.L3:
        mov     eax, 7
        ret
.L2:
        mov     eax, 0
        ret
.L9:
        mov     eax, 15
        ret

As we can see, the two codes produce completely different Assembly code. But still, both of them seem to be close to the same length. How can one be more optimized than the other? It’s all about how the code is executed. Imagine the scenario of receiving value = 5 in the if-else statement. It has to go through all the cmp and jmp instructions before we reach the value = 5 situation. But in case of the switch statement, it multiplies the value of value with 8, (because each address in the table is 8 bytes long) and jump that amount forward. Which lands us immediately at the mov and ret commands for the value of 7. This is called a ‘Jump Table’.

So, while the if-else statement was looking one after the other for the condition of value = 5, the switch statement mathematically moved execution to the 5th instruction. See below for a simplified breakdown.

if-else:
is 1 = 5? --> no, then is 2 = 5? --> no, then is 3 = 5? --> no, then is 4 = 5 no, then is 5 = 5, yes, then return 7

switch:
move 5 steps below --> return the value there

Now imagine hundreds of possible values. The execution time saved can be staggering. For those of you curious, the if-else statement gave us O(n) and the switch statement gave us O(1).

However, this is not always the case. If the conditions don’t follow a mathematical pattern, this falls apart and we don’t see much difference.

However, if you paid close attention, you see that I used a compiler flag called -fno-jump-tables in the if-else statement. This is because modern compilers are smart to identify the existence of a jump table, even in an if-else statement.

But, does this mean that it’s not useful to use a switch statement instead of the if-else? Well, not exactly. The switch statement is a lot more elegant in certain code patterns. Also, sometimes the compiler might not be able to identify the pattern and be able to optimize an if-else statement unless you use a switch statement.

In conclusion, switch statements are awesome! But still, with modern smart compilers, it is not always the case that if-else statements are bad. So next time you use an if-else statement for checking an integer, maybe consider using a switch statement.

sudo usermod -a -G dialout $USER

This might be a new security feature but, I will give a few pointers on how to actually setup Arduino on your Ubuntu machine.

Installation

The recommended, and the method I also use, is to install the Arduino IDE through the Flatpak repo. You can install the Classic IDE or the modern IDE. If you do not have Flatpak setup, you can follow the simple guide given by the Flatpak developers. Then, you can open the Gnome Software Centre, search for ‘Arduino’, and install the IDE.

Uninstalling brltty

brltty is a preinstalled program on Ubuntu that’s known to cause problems with serial devices. So uninstall it using the following command. Unless you heavily rely on accessibility inputs, this program should not be important to you.

sudo apt remove brltty

Changing User Access to Serial Port

This actual fix is to give permission to the current user to access /dev/ttyUSB0 or whatever device that you have connected to Arduino. You can see the serial port that Arduino is trying to connect to. Use the following command to give your user the access to this device. Note that every time you disconnect and reconnect the device, you have to run this command.

sudo chmod a+rw /dev/ttyUSB0

Here, /dev/ttyUSB0 is the device that I want to connect to, yours may vary, and you have to add this here instead of /dev/ttyUSB0. sudo provides admin privileges to the current command, chmod asks the device to edit access, a indicates the current user, +rw indicates read + write access and finally, /dev/ttyUSB0 is the device.

Not sure which device to connect to? An easy way is to use the following command.

ls /dev/tty*

This lists all the serial devices currently connected to your computer. In most cases, the device might be called ttyUSB0 or any other variant of ttyUSB…. First run this command without the device attached, then run again WITH the device attached and see which device appeared. This is the serial device. You can use that to upload your code.

Hope this helps, I will continue to update this post with any further information I find on this matter, including any permanent fixes as well.

Kernel driver not installed (rc=-1908)

The VirtualBox Linux kernel driver is either not loaded or not set up correctly. Please reinstall virtualbox-dkms package and load the kernel module by executing

'modprobe vboxdrv'

as root.

If your system has EFI Secure Boot enabled you may also need to sign the kernel modules (vboxdrv, vboxnetflt, vboxnetadp, vboxpci) before you can load them. Please see your Linux system's documentation for more information.

where: suplibosinit what: 3
VERR_VM_DRIVER_NOT_INSTALLED (-1908) - The support driver is not installed. On linux, open returned ENOENT.

The error suggests running modprobe vboxdrv as root, but this shows an error similar to the following:

modprobe: ERROR: could not insert 'vboxdrv': Key was rejected by service

The Issue

The issue lies in Secure Boot. Your computer might have secure boot enabled, as is in most modern computers. Secure Boot is a security feature designed to prevent malicious software from loading during the boot process. It works by ensuring that every piece of code, including the operating system and its drivers, is signed with a trusted digital signature. Secure boot requires that any kernel module loaded be signed with a key that your system's Secure Boot trusts.

The Easiest Solution (Not Recommended)

The easiest solution is to go to your computer’s BIOS and disable secure boot. But this is both a security risk and a potential issue. It is important to not mess around with security, so do this option if you want to take the risk.

The Actual Fix

Setup

Before we begin, it is important that we install the latest VirtualBox program. You can find it in the Downloads page of the VirtualBox website. Download the appropriate package for your distribution and install it using:

sudo apt install ./virtualbox-7.2_7.2.0-170228~Ubuntu~oracular_amd64.deb

The package name might be different in your situation, so make sure you modify the command accordingly.

Applying the Fix

The first step is to install the mokutil package. mokutil is a command-line utility for Linux that provides a user-friendly way to manage the Machine Owner Key (MOK) list, which is a crucial component for systems with UEFI Secure Boot enabled. It allows you to import, delete, and list cryptographic keys that are used to sign bootloaders and kernel modules, like the VirtualBox driver. This tool acts as a bridge between the Linux user space and the firmware's Secure Boot key databases, allowing you to add new trusted keys without having to disable Secure Boot entirely.

To install mokutil, use the following command. This is given to align with the apt package manager which is common in most Debian based distributions such as Ubuntu and Cinnamon. Make sure to look into how you can install the same thing, if you do not have a Debian based system.

sudo apt-get update
sudo apt-get install mokutil

Follow the usual way that you install a package on Linux and you should be good.

Next, we will create an RSA key. To do this, first let’s switch to the root user using the following command.

sudo su

Once you have root user access, we will create a new folder to handle key signing related work and move into it.

mkdir /root/signed-modules
cd /root/signed-modules

Now we’re ready to create the RSA key. Use the following command to create the RSA key.

openssl req -new -x509 -newkey rsa:2048 -keyout MOK.priv -outform DER -out MOK.der -nodes -days 36500 -subj "/CN=VirtualBox/"
chmod 600 MOK.priv

Next, we will install this key to the kernel using the following command. This will ask for a password. Make sure to remember the password you provided, as this comes in handy later.

mokutil --import MOK.der

Now reboot your computer and on reboot, you will see a blue screen which ask for the certificate. Move through this menu as Enroll MOK > Continue > <previous password>. The computer will now turn on as expected.

Once rebooted, we will log back in as the root to do the signing.

sudo su

Enter the following command to find where the file signing command is.

find /usr/src -name sign-file

Now we will move into our working folder and create a new script to automate our signing.

cd /root/signed-modules
nano sign-virtual-box

In the file, paste the following script.

#!/bin/bash

for modfile in $(dirname $(modinfo -n vboxdrv))/*.ko; do
  echo "Signing $modfile"
  /usr/src/linux-headers-6.14.0-28-generic/scripts/sign-file sha254 \
                                /root/signed-modules/MOK.priv \
                                /root/signed-modules/MOK.der "$modfile"
done

Here, the path /usr/src/linux-headers-6.14.0-28-generic/scripts/sign-file should match the output you got before with find /usr/src -name sign-file.

Now run the script after modifying the execution privileges.

chmod 700 sign-virtual-box
./sign-virtual-box

This should allow you to now run any virtual machines without any issues.

An Additional Issue

However, I also did run into another issue where I had to run the following command after every reboot to get the virtual machines to run, other than the above fix. This might or might not be the case.

sudo modprobe -r kvm_intel

This is used to unload the kvm_intel kernel module, which is a driver that allows the KVM (Kernel-based Virtual Machine) hypervisor to leverage the virtualization extensions found in Intel CPUs. The modprobe -r part of the command specifically tells the system to remove (or unload) the specified module.

Reference

• https://stackoverflow.com/questions/61248315/sign-virtual-box-modules-vboxdrv-vboxnetflt-vboxnetadp-vboxpci-centos-8

• https://askubuntu.com/questions/1537180/modprobe-vboxdrv-could-not-insert-vboxdrv-key-was-rejected-by-service

How do you start working?

• Clone the Pixel Graphics Engine repository, or download a release ZIP.

• Rename the project to whatever you prefer.

• Open the project in Processing.

• Edit the code and run.

There’s already placeholder functions provided for ease of development. You can simply replace the dummy code with your own.

Development Structure

• Add Sprites: Modify CreateSprites() in contents.pde

• Custom Patterns: Create new Pattern objects for different shapes/animations.

• Logic: Add game or animation logic in PerformLogic

Main Components

1. Pixel Grid

• Resolution: Set via pixel_res (PVector(x, y))

• Pixel Size: Set via pixel_size (PVector(x, y))

• Offset: Set via pixel_offset (PVector(x, y))

2. Sprites

Defined in contents.pde Created using the Sprite class (driver.pde) Example: Five ball sprites with random colours and movement

3. Driver

Manages pixel updates, rendering, and sprite interactions See Driver

4. Animation & Patterns

Sprites use Pattern objects for animation frames Supports rotation, flipping, and key frame control

5. Custom Logic

Add per-frame behaviours in PerformLogic

Make sure to mention the Pixel Graph Engine when sharing things you made with it. Happy coding!

The shutdown command in Linux (Bash) is a powerful utility used to safely halt, power off, or reboot the system. It allows administrators to schedule these actions and notify logged-in users. The general structure of this command is as below:

shutdown [OPTIONS...] [TIME] [MESSAGE]

• [OPTIONS...] - Controls the specific action (halt, power off, reboot) and other behaviours.

• [TIME] - Specifies when to perform the shutdown. This is often a mandatory argument if you want to specify a message or schedule the shutdown.

• [MESSAGE] - An optional message to be broadcast to all logged-in users.

Under [OPTIONS...], the shutdown command allows several options for the shutdown process.

• -H/--halt - Halts the machine. This stops all CPU functions but leaves the power on.

• -P/--poweroff - Powers off the machine. This is often the default behaviour if neither -h (legacy option to override the previous command unless the previous command is —halt) nor -r is specified, completely cutting power.

• -r/--reboot - Reboots the system.

• -k - Do not actually shut down, power off, or reboot. Instead, just send the wall message to all logged-in users. This is useful for testing scripts or broadcasting warnings without performing the action.

• -c - Cancels a pending shutdown. This can only be used if a time argument was specified previously to schedule a shutdown. You cannot specify a TIME or MESSAGE with this option.

• --no-wall - Do not send a wall message before halting, powering off, or rebooting.

• --show - Shows a pending shutdown action and time if there is any.

• -t SEC - Tells init (or systemd) to wait SEC seconds between sending warning messages and the kill signal to processes. Defaults to 5 seconds.

• -f - Skips the file system check (fsck) on the next reboot. Use with caution as it can lead to data inconsistencies if not used properly.

• -F - Forces the file system check (fsck) on the next reboot. Useful after an unclean shutdown.

Under the [TIME] argument, you can provide a timeout for the shutdown to occur.

• now - Triggers an immediate shutdown. This is an alias for +0.

• +m - Specifies a shutdown in m minutes from now. For example, +10 means shutdown in 10 minutes.

• hh:mm - Specifies an absolute time in 24-hour format. For example, 17:30 means shutdown at 5:30 PM.

Under [MESSAGE] argument, you can specify a message to be broadcasted to all logged-in users of the device before shutting down.

Here are a few examples with descriptions as to what they do:

sudo shutdown now

Shuts down the system immediately.

sudo shutdown -r +5 "System rebooting for maintenance. Please save your work."

Reboots the system in 5 minutes with the message ‘System rebooting for maintenance. Please save your work.’

sudo shutdown -P 23:00

Shut down the system at 11:00 PM.

sudo shutdown -c

Cancel any pending shut-downs.

sudo shutdown -k "The system will not be going down for maintenance."

Do not shut down or reboot but only display the message ‘The system will not be going down for maintenance.’

It is important to remember that the shutdown command require administrator privileges. Thus, it is important to run the shutdown command with sudo. Although not that important to remember, if a shutdown is scheduled, it sends warning messages to logged-in users, allowing them to save their work. A file /run/nologin is created (usually 5 minutes before the scheduled time) to prevent further logins.

On modern Linux distributions using systemd, shutdown often acts as a compatibility wrapper, internally invoking equivalent systemctl commands (e.g., systemctl poweroff, systemctl reboot, systemctl halt). While systemctl offers more granular control over system states, shutdown remains a convenient and widely used command, especially for scheduled actions.

While shutdown is the most common command, the following aliases are also available to simplify the specific commands:

reboot

Simply reboots the system, similar to the command shutdown -r now.

halt

Simply halts the system, similar to the command shutdown -H now.

poweroff

Simply powers off the system, similar to the command shutdown now.

Other than this, the underlying systemctl provide a lot more options should you choose to use the underlying commands:

• sudo systemctl poweroff - Powers off the system immediately.

• sudo systemctl reboot - Reboots the system immediately.

• sudo systemctl halt - Halts the system immediately (may or may not power off, depending on system configuration).

• sudo systemctl suspend: -Puts the system into a low-power state, keeping memory powered (like sleep mode).

• sudo systemctl hibernate - Saves the system's state to disk and powers off, allowing a full restore upon next boot.

• sudo systemctl hybrid-sleep - Attempts to suspend to RAM and disk (combines suspend and hibernate).

The systemctl commands are graceful shutdown commands, meaning that they will attempt a graceful shutdown, stopping processes and syncing file systems before the final action. Using -f or --force with any of them can bypass these graceful steps, potentially leading to data loss if not used carefully.

Reference

• https://man.archlinux.org/man/shutdown.8.en

• https://man.archlinux.org/man/reboot.8

• https://man.archlinux.org/man/core/systemd-sysvcompat/poweroff.8.en

• https://man.archlinux.org/man/halt.8

• https://man.archlinux.org/man/systemctl.1

The WOEUSB tool managed to create a bootable Windows pen drive with minimal effort. It is developed specifically for this purpose, and it manages to do it really well. This quick article will guide you on creating a Windows ISO on Linux using WOEUSB.

Downloading an ISO

It is important to download a valid Windows ISO. They can be found through Microsoft’s official website. Given below are quick links to download Windows ISOs. Note that Microsoft might change these URLs.

• Windows 11

• Windows 10

Installing WOEUSB Tool

First you need to install the required libraries.

sudo apt install git p7zip-full python3-pip python3-wxgtk4.0 grub2-common grub-pc-bin parted dosfstools ntfs-3g

Next, we can install the WOEUSB tool through Python.

sudo pip3 install WoeUSB-ng --break-system-packages

Next, we will clone the WOEUSB Repo.

git clone https://github.com/WoeUSB/WoeUSB-ng.git
cd WoeUSB-ng

After this, we can run the tool from the terminal.

./WoeUSB/woeusbgui

It will ask for the admin password, which should be provided. In certain cases, WOEUSB will immediately close after first install, stating that policy is updated. In this case, you have to open it again using the same command.

Creating the ISO

Select ‘From a disk image (iso)’ and use the file picker to choose your downloaded ISO. Select the target device under ‘Target device’ and click on ‘Install’. A warning will pop up for confirmation. Make sure that you’ve selected the correct device from the Target devices. Also note that the device will be completely wiped. If you’re OK with this, click on ‘Yes’ to start the process.

This will start the installation process.

Once installation is done, you will see an ‘Installation Successful’ Message.

Remove the installation media from your computer and use it to install Windows.

Uninstalling WOEUSB

WOEUSB can be uninstalled using the following commands.

cd ..
rm -rf ./WoeUSB-ng/
sudo pip3 uninstall WoeUSB-ng --break-system-packages

Conclusion

While it is hard to create a Windows installation media on Linux, it is not impossible. With the use of WOEUSB, we can relatively easily create a Windows installation media. The steps outlined in this article will be quite helpful in this matter.

Let's start with the concept of a stack. Imagine a stack of plates in your house: you can only add a new plate to the top, and you can only take the top plate off. This "Last-In, First-Out" (LIFO) principle is how the stack works. In your computer, a similar thing happens every time you call a new function, declare a variable, or return from a function.

A stack of plates [AI generated]

We can visualize the memory as a tall shelf with thousands of tiny drawers that can hold a 'byte' of data. Now, it is important to manage this memory efficiently to take the best out of the system and to mitigate mistakes. This is where memory management comes into play.

A stack of drawers [AI generated]

The Stack, in the sense of computer memory management, is one such strategy. Now think of the plate analogy we discussed before, and the assign the same ruleset to the tall 'memory' shelf. You have to start from the bottom most drawer. You can only put a 'byte' into the drawer above the one last filled. And you can only take the topmost one at a time.

Typical SRAM structure of the ARM memory

Just like that, the memory allocated to the stack is only accessible in the above discussed way. Think of the stack as a dedicated workspace for managing critical information. The stack is crucial to handle:

• Function Calls: Every time a function is called, its details are 'pushed' onto the stack. When the function finishes, its information is 'popped' off.

• Local Variables: The temporary data a function needs to do its job is stored right there on the stack.

• Program Flow: It's the stack that ensures your program returns to the exact spot it left off after completing a task or jumping to a different part of the code.

Now we will see how the Stack works. In real memory, the stack starts from the highest available memory address and move down. To further understand how the stack behaves, we will use a sample C code as an example.

int square(int num) {
    int result = num * num;
    return result;
}

int main() {
    int x = 2;
    square(x);
}

The compiled x86-64 Clang Assembly code is as below.

square:
    push rbp
    mov rbp, rsp
    mov dword ptr [rbp - 4], edi
    mov eax, dword ptr [rbp - 4]
    imul eax, dword ptr [rbp - 4]
    mov dword ptr [rbp - 8], eax
    mov eax, dword ptr [rbp - 8]
    pop rbp
    ret

main:
    push rbp
    mov rbp, rsp
    sub rsp, 16
    mov dword ptr [rbp - 4], 2
    mov edi, dword ptr [rbp - 4]
    call square
    xor eax, eax
    add rsp, 16
    pop rbp
    ret

If you analyse the code, every time we switch functions, we're pushing the Base Pointer (RBP) onto the stack. Then we change the RBP to the current Stack Pointer (RSP). This way, we know where to return to after the function executes and returns. On the other hand, we create space for all the local variables of that function within the stack as soon as we're done with it. After execution, the stack pops all of that data and move back to where we started.

This is better visualized in the below animation.

From the simplest script to the most complex operating system, the stack is silently working behind the scenes, ensuring that our digital world runs smoothly and predictably. It's a testament to how some of the most powerful and enduring ideas in computing are rooted in simple, yet effective, abstractions.

Reference:

• Wikipedia article on the Stack data type: https://en.wikipedia.org/wiki/Stack_(abstract_data_type)

• Wikipedia article on the Call Stack: https://en.wikipedia.org/wiki/Call_stack

• Code sample on Compiler Explorer: https://godbolt.org/z/1vddacPM3

Installing the nRF Connect for Desktop Application

The first thing is to install the nRF Connect for Desktop application. Go to the Downloads section. First of all, download the latest package for your preferred operating system.

For Windows, the application comes as an exe installer. Simply double-clicking the downloaded exe and following the given instructions will be ideal. For Linux though, the application comes as an AppImage. AppImage is a packaging format which bundles all the dependencies and libraries as one single executable which can just be run by double-clicking. However, the AppImage version that Nordic has used to bundle the application is outdated and for modern systems, just double-clicking will not help. In such a case, I'd recommend you follow this tutorial to set up the application. Even if it works for you, this method will be faster and more reliable as it sets up the program to run without mounting itself. DO NOT ATTEMPT TO INSTALL libfuse2as it WILL BREAK YOUR SYSTEM.

Now that we have the nRF Connect for Desktop ready, we can open the application by double-clicking the AppImage or from the app launcher. This will open the nRF Connect for Desktop application.

Installing a Preferred Toolchain

The next important thing to do is the install the preferred toolchain. In the Apps tab of the nRF Connect, you will find an entry called Toolchain Manager. Toolchain Manager allows you to manage the different toolchains we need for microcontroller development. We will start by installing the Toolchain Manager. Click on the Install button next to the Toolchain Manager entry and wait for the entry to complete the installation.

If the installation succeeds, the Install button will be replaced by an Open button. Click on the Open button to open the Toolchain Manager. Now we will install a preferred toolchain. It's suggested to install the latest toolchain available unless you have a specific reason to use another version. To do this, click on the Install button as usual. This will prompt a small window asking you to confirm the install directory.

The default path would be the ideal location to leave the toolchains however, if you want to install in a different location, you can click on the Change directory button and choose the location. Note that once installed, changing the toolchain location will be hard, so choose the proper place to install your toolchain. Once complete, click on Continue installation to install the selected toolchain. Installing a toolchain will take a considerable amount of time depending on your hardware and network connection. Once complete, you will get a window similar to below.

Installing the VS Code Editor

For development, nRF Connect supports the VS Code code editor. If you already have VS Code installed, you can continue with installing the extensions. However, if you don't have VS Code installed, you can install it by downloading the package from the official website. It is recommended to use the official website to install VS Code rather than other methods like Flatpaks or 3rd party websites. The installation method should be pretty typical and does not need any explanation.

Installing the nRF Command Line Tools

Once VS Code is done installing, you can click on the Open VS Code button that appears after the installation of the toolchain. However, this will prompt a message asking you to install nRF Command Line Tools.

Click on the provided link to open the download location. From the website, download the correct installer for your preferred operating system. As usual, the installation will be typical and you can follow the instructions provided. For Windows, it will be a standard installer as an exe while for Linux, it will be a deb file.

Installing the Environment Variables

It is a good practise to also setup the required environment variables for the development to go smoothly. For this, in the Toolchain Manager, click on the drop down button next to Open VS Code button. This will show multiple options that include Generate environment script.

Clicking on this will prompt you to select a place to save the generated script. Save it anywhere you want and navigate to that location with your file explorer. For Windows, this will create a cmd file that can be double-click to install. Provide the Administrator password if prompted. For Linux, you can right-click in the file explorer and click on Open in Terminal. This will open a terminal window with the path as the directory in which you have the bash script file. Enter the below two commands to run this script.

chmod +x ./env.sh
./env.sh

This will install the environment variables in the operating system. It is recommended to restart your operating system before proceeding with the next steps.

Setting up the VS Code Development Environment for nRF

Once complete, it is recommended to restart the operating system before proceeding. Now you can open the toolchain manager again and click on Open VS Code. Now you will see a new message asking you to install the VS Code extensions.

Clicking on Install missing extensions button will install all the extensions one by one. Once all the installations are complete, you can click on Open VS Code again to open the VS Code editor. This will open the VS Code where you can start your development. On how to start development, you can refer to this link.

Fixing the JLinkARM DLL load failed Error

Sometimes when trying to flash the code to your Nordic device, you might end up with an error that looks like above. In this case, the issue might be an out-of-date JLink driver installed. Go to the SEGGER JLink download page and download the latest driver for your operating system. As usual, the installation is straightforward and does not need any explanation. Once done, the Flashing should work as expected.

The nRF development environment is a powerful and versatile ecosystem for creating applications for Nordic Semiconductor's nRF series of low-power wireless SoCs. It caters to developers of all skill levels, offering options for both beginners and seasoned professionals. So enjoy coding with your new nRF development board.

References

• nRF Connect for Desktop download page

• VS Code download page

• nRF Command Line Tools download page

• SEGGER JLink tool download page

• nRF Series SoCs: These are the core of the development environment. Nordic Semiconductor offers a range of nRF chips (like the nRF51, nRF52, nRF53, and nRF91 series), each with varying capabilities in terms of processing power, wireless protocol support, and features. These SoCs are designed for low-power operation, making them ideal for battery-powered IoT devices.

• nRF Connect SDK (Software Development Kit): This is a crucial software tool for developing applications for nRF devices. It provides a comprehensive set of tools, libraries, and examples for building firmware. The nRF Connect SDK is based on the Zephyr RTOS (Real-Time Operating System), which offers a robust and scalable platform for embedded development.

• nRF Connect for Desktop: This is a PC-based application that provides various tools for testing, programming, and debugging nRF devices.

• nRF Connect for VS Code: This Visual Studio Code extension streamlines nRF Connect SDK development within the popular VS Code IDE. It simplifies tasks like building, flashing, and debugging.

• Development Kits (DKs): Nordic Semiconductor provides development kits that allow developers to prototype and test their applications. These kits typically include an nRF SoC, along with other necessary components.

The reason for starting this article series is to share the knowledge I received about the nRF development flow. Sometimes it can get overwhelming to enter into the nRF toolchain because of the lack of sources online. However, I can recommend the Nordic Dev Academy as it is a good starting point for further information on the Nordic toolchain and SDKs.

Making the Website Itself

There are multiple ways to make a website. You can use WordPress, download a website from the internet or even make one yourself from scratch. If you want to go with WordPress, you can follow the online resources and get a working website up quickly. If you prefer to develop your own website from scratch, it might be a bit more complicated; I’d suggest you go on this route only if you know what you’re doing. An easy way is to download a sample website from the internet. There are great sites like www.free-css.com. Simply download one and modify it according to your liking.

Hosting the Website

This is where most people get confused. While there are so many hosting providers - Microsoft Azure, Google Firebase, Amazon AWS, Hostinger, etc, there’s one hosting provider that you might not be considered or even know about: GitHub. That’s right, you can host your personal website on Github with little to no effort, costing zero money.

What you have to do is go to your GitHub account and create a new repository. This repository should be named <your-github-name>.github.io. Here <your-github-name> refers to your Github profile name. For example, my GitHub name is asankaSovis, so I have my repository titled asankaSovis.github.io. Make sure that the repository is Public. You can choose to initialize the repo with a README, add a .gitignore file or even choose a license; it doesn’t matter.

Once the repository is created, you can clone the repo to your computer. For this, you can use the Code > Clone > HTTPS option as below. Under this, click on the copy button to copy the URL and paste it into your terminal with the below command. Note that <URL> refers to the URL that we copied before.

git clone <URL>

If you’re using Mac or Linux, you will have Git installed by default, so providing the above command would be sufficient. If you’re using Windows, you might need to install Git. Refer to the official documentation for how you can install Git. Also, you have to make sure that Git is initialized with your GitHub username and password. Refer to the Github documentation for this.

Once cloned, open the directory in your file browser. Copy your website to this directory while making sure that the index.html file is at the root of this cloned directory.

Now, we have to commit the changes and sync the changes to the source. To do this, you can use the following commands in order.

git add .
git commit -m "Initial Commit"
git push && git pull

Now if you open the GitHub repo on your browser, you will see a yellow dot in the interface. Clicking on this will reveal the status of publishing your website. When this yellow dot turns into a green checkmark, the website is online.

That’s it, your website is now online. Visiting the <your-github-name>.github.io website will reveal your very own personal website. Here <your-github-name> refers to your Github profile name, as mentioned before.

Adding Our Own Custom Domain

You don’t have to stop here; you can host the website on your own URL as well, with no need for the <your-github-name>.github.io URL at all. To do this, we need our very own domain, and it will cost you a bit. You can use any domain provider: GoDaddy, Hostinger, Bluehost, etc. Here, I will be using Namecheap.

Visit the Namecheap website and create your account. After logging back into your account, go to the homepage. Here, you can search for whatever domain name you want.

Once you search for a name for your domain, Namecheap will show you a list of domains available for your purchase. Double-check carefully and choose a domain that suits you well. You must consider the intended audience, initial cost, yearly payment, etc. when you buy a domain.

Once you have the right domain, add it to the cart, go to checkout and buy it. You will need to provide your card details at checkout. After you complete your transaction, go to Your Account > Dashboard to view the newly registered domain. Under Dashboard > Recently Active in Your Account, you will see the domain.

Click on Manage, and under this, you have to click on Advanced DNS. Here, add the following under Host Records. You can use the ADD NEW RECORD button.

A Record         @        185.199.108.153                30 min
A Record         @        185.199.109.153                Automatic
A Record         @        185.199.110.153                Automatic
A Record         @        185.199.111.153                Automatic
CNAME Record     www    <your-github-name>.github.io.    Automatic

Once this is done, go to your website’s Github repository again. Here, go to Settings > Pages > Custom Domain. In the textbox, enter the domain you just registered. Under this, a yellow dot will appear, followed by a text that reads ‘DNS Check in Progress. ’ Wait for a few minutes and if all is well, this will turn into a green tick mark followed by a text that reads ‘DNS check successful’. If not, review the steps again to see if you have followed everything correctly. Sometimes, it will take several hours for domains to start working correctly, so consider giving it some time.

Now if you visit your domain on your browser, you will see your website hosted. The following variations of the URL will be working as expected.

http://<your-domain>.<TLD-domain>
http://www.<your-domain>.<TLD-domain>
https://<your-domain>.<TLD-domain>
https://www.<your-domain>.<TLD-domain>
<your-domain>.<TLD-domain>
www.<your-domain>.<TLD-domain>

Here, <your-domain> refers to your registered domain and the <TLD-domain>. refers to the Top Level Domain (TLD) you registered it under. For example, .com, .org, .it, etc.

Extending the Domain to Your Hashnode Blog

If you have an active blog in Hashnode, you can do the same thing to host your blog under your custom domain. Go to your Hashnode profile and go to the dashboard of your blog. Under Blog Dashboard > Domain, you will find the required settings. Click on Custom domain and in the text box, enter a variant of <sub-domain>.<your-domain>.<TLD-domain>. A good option would be blog.<your-domain>.<TLD-domain>. Click on Add domain.

Now you have to go back to you Namecheap Dashboard, and update the Host Records again as we did before to include the blog URL as well.

A Record         @        185.199.108.153                30 min
A Record         @        185.199.109.153                Automatic
A Record         @        185.199.110.153                Automatic
A Record         @        185.199.111.153                Automatic
CNAME Record     www    <your-github-name>.github.io.    Automatic
CNAME Record     blog    hashnode.network.               Automatic

Once updated, you can visit the Hashnode settings page we were in before and it should show a green check mark followed by Valid under the Status tab as below.

This indicates that the new domain is ready to be used. Visiting blog.<your-domain>.<TLD-domain> or whatever you chose before will show your Hashnode blog. If not, review the steps again to see if you have followed everything correctly. Sometimes, it will take several hours for domains to start working correctly, so consider giving it some time.

Create Redirects to Your Socials

We do not have to end there. You can also create redirects to your social media as well using your custom domain. To do this, instead of Advanced DNS, go to Domain under your Domains List in Namecheap like we did for the personal website. Here, under Redirect Domain, you can set URLs to redirect from your domain. For example, let’s say you want the URL facebook.<your-domain>.<TLD-domain> to automatically redirect to your Facebook profile, simply click on ADD REDIRECT and enter facebook.<your-domain>.<TLD-domain> as the Source URL and the URL to your Facebook profile under Destination URL. Now if you visit, facebook.<your-domain>.<TLD-domain>, the URL will be automatically forwarded to your Facebook profile. You can add as many redirects as you want like this.

Create Custom Email Redirects

Another awesome feature you will get is the option to redirect emails. No need to use your personal email to advertise yourself. You can create your email address using your domain. Note that this will not be a brand-new email address but rather a forwarding email address. You will still need a proper email address set up to receive emails.

Under the same setting Domain we were in before, go to Redirect Email. Here, click on ADD FORWARDER and add an alias under Alias and your email address under Forward to. An alias could be, for example, contact, hello, or enquiries. Let’s say you entered ‘contact’ as an alias. Any emails sent to contact@<your-domain>.<TLD-domain> will be forwarded to the personal email you entered under Forward to. You can add as many aliases to as many emails as you want like this.

Conclusion

Having your own website is important to increase your reach and advertise yourself as an individual on this ever-expanding internet. Here, I discussed a way you can make your small home in this vast network. On the other hand, buying your domain will also have its advantages, as we discussed. So, make the best out of this great opportunity.

Reference

• Github Homepage: https://github.com/

• Namecheap Homepage: https://www.namecheap.com/

• Hashnode Homepage: https://hashnode.com/

• Git Homepage: https://git-scm.com/

• Git Documentation: https://git-scm.com/doc

• Git Tutorials: https://git-scm.com/docs/gittutorial

• Configuring a custom domain for your GitHub Pages site: https://docs.github.com/en/pages/configuring-a-custom-domain-for-your-github-pages-site

• How to Map a Custom Domain?: https://docs.hashnode.com/help-center/blog-domain/how-to-map-a-custom-domain

• Free CSS: https://www.free-css.com/

• WordPress Builder: https://wordpress.com/go/

So first off, how do you change the wallpaper in Linux? Well, it depends on the distro! Since Ubuntu is a common distro and it’s based on Gnome, you can use the Settings app to change the wallpaper. The same goes for most other famous distros.

But this lacks the option to time the changing of the wallpaper, which is kind of boring. Now I’ve got to admit, there might be better options for wallpaper slideshows in Linux. Having a script is not at all optimized let alone elegant. But I like the simplicity of the idea.

Now if we want to automate the wallpaper creation, we must first have a command that can change the wallpaper. In fact, we do!

gsettings set org.gnome.desktop.background picture-uri-dark /path/to/wallpaper.jpg

Now this is for the dark theme, for the light theme, it’s the same but as below.

gsettings set org.gnome.desktop.background picture-uri /path/to/wallpaper.jpg

Now it’s a matter of adding the sleep and an indefinite loop.

We want to be able to run this script automatically on startup. Clone the components from the GitHub repo. If you do not know how to clone the repo, you can also download a release from Releases. It is recommended to download the latest version.

Create a directory in ~/Pictures/ called Wallpapers. Copy the required wallpapers to this directory.

Copy the change_wallpaper.sh to a convenient location, possibly to your home (~) directory. Open a terminal from the copied location. Enter the following command to make the script run automatically on startup.

SCRIPT_PATH="$PWD/change_wallpaper.sh"; SERVICE_NAME="change_wallpaper.service"; chmod +x $SCRIPT_PATH; echo "[Unit]
Description=My Script
After=network.target

[Service]
ExecStart=$SCRIPT_PATH

[Install]
WantedBy=default.target
" | tee ~/.config/systemd/user/"$SERVICE_NAME"; systemctl --user daemon-reload; systemctl --user enable "$SERVICE_NAME"; systemctl --user start "$SERVICE_NAME"

You have to make sure not to run this command with sudo privileges. That should give you a wallpaper slideshow!

Now it would be boring to have a script that doesn’t have any customization options, so I included additional features to the script as well. Adding additional wallpapers is as simple as copying them to the Wallpapers directory. Both JPEG and PNG wallpapers are supported.

You can also customize the script to your liking. Simply open the script in a text editor and change the following variables:

1. wallpaper_path="/home/$USER/Pictures/Wallpapers" - Wallpaper path: The wallpapers must be in a directory. Enter the directory path here between double quotes. Do not enter the path to a file. Make sure to provide an absolute path relative to the root.

2. update_wallpaper_every=10m - Time to update the wallpaper: Replace 10m with your own value. This can be given as: s or (no suffix): seconds (default), m: minutes, h: hours, d: days. Decimals and combinations are also accepted. For example: update_wallpaper_every=5 : 5 seconds, update_wallpaper_every=5s : 5 seconds, update_wallpaper_every=2m : 2 minutes, update_wallpaper_every=1.5h : 1.5 hours, update_wallpaper_every=7d : 7 days, update_wallpaper_every=1h30m : 1 hour and 30 minutes. It is recommended to provide a time greater than 5 seconds. The script is also not set to persist time every reboot. Therefore might not change the wallpapers properly for higher timeframes.

3. update_list_every=5 - Number of times to wait to update the list of images: This will wait until the given number of times of wallpaper updates to update the list of images in the wallpaper path. For example if update_wallpaper_every=10m and update_list_every=5, the list of wallpapers will be updated every 50 minutes.

Further modifications can be done to the script itself if needed.

Now there are cases where you might want to temporarily stop the script or permanently get rid of it. So:

1. In case you want to pause the changing of wallpapers, you can create a file called .override inside the same Wallpapers directory which will pause the slideshow indefinitely until the file is deleted again.

2. You can check the status of the script by using the following command.

systemctl --user status "change_wallpaper.service"

NOTE: Do not run this command with sudo.

3. The script can be temporarily stopped by killing the script.

sudo kill -9 $(ps -eo pid,command | grep /bin/bash | grep live_wallpaper_script.sh | tr -d " " | tr "/" "\n" | head -n 1)

NOTE: Have to run this command with sudo.

4. The script can be permanently stopped and removed by deleting the service file.

SERVICE_NAME="change_wallpaper.service"; systemctl --user stop $SERVICE_NAME; systemctl --user disable $SERVICE_NAME; rm ~/.config/systemd/user/"$SERVICE_NAME"

NOTE: Do not run this command with sudo.

5. In case the script is modified, the service can be restarted to pull updates to the script.

systemctl --user restart "change_wallpaper.service"

NOTE: Do not run this command with sudo.

To report bugs and request features, go to GitHub issues and create a new Issue. Make sure to include the terminal output and a clear explanation of what you were trying to do and what happened. Also, include device information such as the distro and install path. It will take some time to provide support.

Anyone can contribute to this project. If you're a bash programmer, any new features or bug fixes are greatly appreciated. Any suggestions are also appreciated along with documentation improvements. The same goes for any bug reporting and feature suggestions. Also, if you're willing to, consider trying all features of this script in your distro and providing any feedback; especially if you're on a different distro.

I ran the script on Ubuntu 24.10.

Whether Linux or Windows, most of us are nostalgic for screensavers. They were not just there to provide any technical requirements but were also a form of art that we loved to enjoy. With time, the requirement for screensavers has faded away; of course, it's simply better to just blank the screen out anyway. But some of us still love the prospect of the screen turning into a lovely display of electronic art whenever we leave the computer for some time. If you're someone like me, then this tutorial will explain to you how to re-enable screensavers on Linux.

Before we proceed, I'd like to point out that in modern systems, it's probably useless to use a screensaver anyway. Most, if not all displays nowadays will turn themselves off when no signal is present. It's probably better for its durability anyway. On the other hand, it's much safer to just turn off the screen from a cybersecurity perspective. Therefore, please proceed with your caution and responsibility with this tutorial as we're dealing with old technology and we can't guarantee security or reliability. If you're unsure, leave your system as is. But for those of you who are willing to take the risk, let's proceed.

The XScreenSaver

Since its heydays, Linux has used XScreenSaver to provide the system with screensaver support. However, in 2011, gnome-screensaver version 3 dropped support for screensavers completely, supporting only simple screen blanking. Since then, we simply see the screen blanking itself after the allocated timeout.

However, development for XScreenSaver is still underway and can be easily done on Linux with just a few steps.

Installing the XScreenSaver

The first step is to install the XScreenSaver on your OS. I am using Ubuntu 23.10 and other Linux distros might have similar steps to what I'm following. In some Ubuntu distros, a program called gnome-screensaver might be present to handle screen blanking. It is important to remove this as it might interfere with the XScreenSaver. To do this, use the following command. In most modern distros, this simply will not even exist; but still, it's better to make sure.

sudo apt-get remove gnome-screensaver

The next step is to install the XScreenSaver along with its dependencies.

sudo apt-get install xscreensaver xscreensaver-data-extra xscreensaver-gl-extra

This is it! Now the OS will have screensaver support. However, some configurations might need to be done before we call it a day.

Changing a Few Settings

If your computer is set to blank after a certain time even when the screensaver is present, is not a good idea. So we will delay the screen blanking time. Go to Settings > Power and set the Screen Blank to 15 minutes. This will ensure that the screensaver has plenty of time before the system kicks in and turns off the screen. You can also set it to Never but I do not recommend it.

Configuring the XScreenSaver

Out-of-the-box, XScreenSaver is set to start the screensaver after 10 minutes. It will choose a random screensaver and display it on the screen. We'd like to choose the screensaver we like to set as the screensaver. Doing this is easy! If you now check your app drawer, you will see a new app titled Screensaver.

Open this and you will see the XScreenSaver configuration page.

Sometimes, you might get a Warning such as the one given below:

Hit OK and you will see a prompt like below:

This indicates that the screensaver daemon started.

On the Screensaver Preferences page, we can change the preferences for our screensavers. Under Blank After, set the number of minutes after which to turn on the screensaver. Also, make sure to uncheck the Fade to Black when Blanking and Fade from Black When Unblanking options under Advanced > Blanking tab. Also, set the Fade Duration to 1 second or it takes too much time to show the screensaver.

The most important option, however, is the Mode: in the Display Modes tab. Change it to Only One Screen Saver to enable the screensaver selection. Now in the list below, you can choose your favourite screensaver as the default. Go through them and choose the ones that you prefer.

For me, the Preview button does not seem to do anything, however, if you prefer to preview the screensaver, simply click File > Blank Screen Now and the screensaver will be displayed on the display.

Optionally, you can change settings on certain screensavers by clicking on Settings.... Note that some screensavers might not have the option to change their settings.

Starting the XScreenSaver Daemon at Startup

If you restart your computer, you'll notice that even after the timeout, the screensaver might not start. The reason is that every time the computer restarts, the XScreenSaver daemon does not run automatically. We will do this by adding a startup entry.

To do this, open the Startup Applications from the app drawer and click on Add to create a new entry.

Under Name: give XScreensaver. Under Command: give xscreensaver -no-splash and under Comment: give Start screensaver daemon.Press Add and then Close to close the application.

Now, every time you restart the device, the XScreenSaver daemon will run automatically.

Fix a Little Inconvenience

If you use the screensaver for some time, you will notice that even when you watch a movie or a YouTube video, the screensaver starts. This can end up being annoying. Unfortunately, there's no proper way to prevent this. But, there's a small hack that we can do to make sure this doesn't happen in most cases.

The trick is to create a bash script that checks if an application is running full screen and disable the daemon if it sees one. This is only a partial fix as whenever you're playing a video without going full-screen, the screensaver will turn on regardless. We will have to deal with it, unfortunately. However, in most cases, we will be doing something on our computer while something is playing without the full-screen mode and it should be fine.

All kudos should go to Terrance on askubuntu.com for coming up with this ideal solution. The workaround below is from the answer he gave to a question titled When I watch a video online the screen turns off after a few minutes, with a few modifications on the terminal.

First, we will install xdotool.

sudo apt install xdotool

Then, we will create a folder to save our script.

mkdir -p ~/.scripts

In this folder, we will create a bash script file.

nano ~/.scripts/check_full.bsh

This will open a nano terminal to type the bash script. In it, paste the following script:

#!/bin/bash

#Get DPMS settings
dpms_set=$(xset -q | awk '/DPMS is/ {print $NF}')

#Get screensaver type and command
scrnsvr='/usr/bin/xscreensaver'
scrnsvrcmd='/usr/bin/xscreensaver -no-splash'

#Sleep Timer in seconds.
SL=300

while true;
do
result=()
#Get all window geometries
all=($(xdotool search --name - | while read win; do xdotool getwindowgeometry $win | awk '/Geometry/ {print $2}'; done))

#Get all screen resolutions detected and build array.
SCREENS=($(xrandr | awk '/\*/ {print $1}'))

SCRN=" ${SCREENS[*]} "

#Get result of all windows and match

for item in ${all[@]}; do if [[ $SCRN =~ " $item " ]] ; then result+=($item); fi; done

#If a result exists disable power management and screensaver
if [[ ${result[@]} ]]; then
    ps -ef | grep $scrnsvr | grep -v grep >/dev/null
    if [[ $? == 0 ]]; then 
    kill $(ps -ef | grep $scrnsvr | grep -v grep | awk '{print $2}')
    fi
    if [[ $dpms_set == "Enabled" ]];then
    xset -dpms
    fi
else    
    ps -ef | grep $scrnsvr | grep -v grep >/dev/null
    if [[ $? == 1 ]]; then
    ${scrnsvrcmd} &
    fi
    if [[ $dpms_set != "Disabled" ]];then
        xset dpms
        fi
fi
result=()
sleep $SL
done

You might need to change the SL=300 value depending on what the screensaver start time is set to. I have set it as 10 minutes; which is 600 seconds. So I chose this value to be 300 as it's half the screensaver start time. This allows the script to correctly detect the presence of a full-screen app without compromising performance.

Save this by pressing the key sequence Ctrl + X > Y > Enter.

Try running the script by entering the following command:

~/.scripts/check_full.bsh

If you get an error that looks like below:

Enter the command:

chmod +x ~/.scripts/check_full.bsh

This will mark the script as executable. Now run the script again from the previous command and it should show like this:

This indicates that the script is running and working. If it throws any errors, you will need to double-check the script.

You can press Ctrl + C and close the terminal.

Next, we will set this script to also start automatically every time we turn on the computer. As before, open the Startup Applications from the app drawer and click on Add to create a new entry. Under Name: give Check_Full. Under Command: give bash -c 'sleep 5 && /home/asanka/.scripts/check_full.bsh' and under Comment: give Prevent screensaver from activating when full screen video is playing. Press Add and then Close to close the application.

Now, every time you restart the device, the script to check for full-screen applications will run automatically.

Conclusion

Screensavers, once a well-known feature of retro computers, have seen their role fade away in the modern days. While their original purpose of preventing screen burn-in on CRT monitors is no longer relevant with today's displays, screensavers still have some benefits and will always hold a nostalgic charm for many of us enthusiasts.

Resources

• 'When I watch a video online the screen turns off after a few minutes' post on askubuntu.com

• Installing XScreenSaver In Ubuntu article on Unixmen

• Article about XScreenSaver on wikipedia.org

• Official XScreenSaver homepage

• Article about screensavers on wikipedia.org

Nowadays, Linux has several packaging methods that allow cross-compatibility among different Linux distros. All of them come with their ups and downs and choosing the one that chooses you is important. But sometimes, we don't have any other option but to use an application that comes in a specific packaging format.

AppImages - A Powerful Packaging Format... But with a Flaw

AppImages are one such format for distributing software on Linux that doesn't require installation. They're essentially self-contained applications that run on most Linux distributions without needing superuser privileges. This makes them a great option for users who want to try out new software without having to worry about messing up their system, or for developers who want to distribute their software more easily.

AppImages are a powerful packaging format but a major issue exists with its use of the libfuse2 library. libfuse2 is a library that allows user-space programs to interact with the Linux kernel's filesystem. Some AppImages rely on it for features like virtual filesystems or encrypted storage. However, starting with Ubuntu 22.04 and other distributions libfuse2 is no longer included by default. This is due to security concerns and technical limitations of the older library version.

Developers are encouraged to upgrade to the latest libfuse3 but some programs have still not upgraded their programs to the libfuse3 library. This makes these AppImages unusable in modern Linux versions.

The Problem

If you try to double-click these AppImages, you might notice that they do not result in anything. In this article, I will use the nRF Connect for Desktop as an example since as of writing this article, it still doesn't work for modern distributions such as mine: Ubuntu 23.10. We can see the actual problem by running it in the terminal.

To do this, navigate to the folder with the downloaded AppImage from Nautilus and right-click on it to select Open in Terminal. On the terminal, typing the name of the package and pressing enter will attempt to run the program from the terminal which will throw the following error.

The Solution

The solution provided in this message is to install libfuse2 using the following command.

sudo add-apt-repository universe
sudo apt install libfuse2

However, if you're on an Ubuntu version on or above 22.04 DO NOT ATTEMPT TO DO THIS as it WILL BREAK YOUR SYSTEM. If done, you will have to reinstall the whole desktop environment as well as all the installed applications. At this point, reinstalling the system is the best option.

But there is a simple and elegant workaround for this issue. This is to unpack the AppImage and run it by executing the script. This has the added advantage of bypassing the need for the operating system to mount a separate filesystem to extract and run the AppImage every time it's executed.

The way you can do this is to enter the following command after opening the terminal in the folder with the AppImage.

chmod +x ./nrfconnect-4.3.0-x86_64.appimage
./nrfconnect-4.3.0-x86_64.appimage --appimage-extract

I'd recommend creating a new folder in your home directory like 'AppImages' and copying the AppImage there before extracting the AppImage in this folder using the above command. Now within this extracted folder, you will find the contents of the app.

Now first open another terminal in this folder and enter the following command to execute the program.

./AppRun

If this results in the file opening in a text editor, enter the following command first to change the file to executable.

sudo chown +x ./AppRun

You will see that the app runs without an issue.

Make an Elegant way to Launch the Application

We can also make the application appear in the App Launcher menu as an entry. To do this, we will rename the folder in which the AppRun file exists to something convenient. In this case, I have already renamed it to nRF.

Now navigate to User Home > .local > share > applications. If .local is not visible, press CTRL + H to reveal hidden files and folders. In this, open a terminal window and use the following command to create a new desktop entry.

sudo nano 'nRF Connect.desktop'

You can use any name for the application name. Make sure to use only letters and numbers along with spaces to reduce conflicts and end the name with .desktop as given. This will open the nano text editor. In it, paste the following. Make sure that the paths in Exec and Icon point to the correct locations.

#!/usr/bin/env xdg-open
[Desktop Entry]
Version=1.0
Type=Application
Terminal=false
Exec=/home/asanka/AppImages/nRF/AppRun
Name=nRF Connect Desktop
Comment=nRF Connect Desktop
Icon=/home/asanka/AppImages/nRF/nrfconnect.png

Here, you can include the path to the AppRun file of your specific application under Exec. The Name and Comment should be the app name that should appear in the launcher. The Icon should point to a PNG of the application. The AppImages usually come with an icon, however, if you do not have one, simply download the logo of the application as a PNG image and copy it into that application directory.

Now save the file by pressing CTRL + X > Y > Enter. Then if you check your launcher, you will see the application icon. Clicking on it will run the program.

Reference

• nRF Connect Desktop Download

• AppImage FUSE Requirement Details

• Wikipedia Article on FUSE

• libfuse GitHub Repository

• Ubuntu 22.04: Appimage doesn't start : libfuse.so.2: cannot open shared object file: No such file or directory - Issue on openshot-qt Github Repository

• How to create desktop shortcut launcher on Ubuntu 22.04 Jammy Jellyfish Linux - LinuxConfig.org

• Official AppImages Site

Installing the Helakuru Sinhala Package

From my experience, the Helakuru package contains the best Sinhala support at the moment, and it's also straightforward to set up. Simply visit the link given here to download the Debian package. For other Linux packaging types, visit this link and choose your preferred distribution.

Extract the downloaded zip file and within this, you will find the Debian installer as 'helakuru.deb' or like.

Now you can double-click this Debian package to open the software centre. If it doesn't open the package in the software centre, right-click and choose 'Open With...' Now choose 'Software Install' and click Open.

Click on Install and it will deploy Sinhala keyboard support on Linux.

Now log out of the device and log back in to activate the changes on the device. Now if you go into Settings > Keyboard > Input Sources > Add an Input Source (+ Sign), you will see Sinhala as an input method.

If you click on Sinhala, you will find multiple entries of Sinhala language installed.

The most familiar options out of these would be Wijesekara (Sinhala (si-helakuru-wijesekara (m17n)) and Phonetic (Sinhala (si-helakuru-phonetic (m17n)). Clicking on either of these and clicking on Add will add these as an input language. Now if you click on the small language icon that appears on the command panel, you will find the selected language preferences appear.

You can add, remove or change these keyboard layouts by clicking on Keyboard Settings in the above menu. Unfortunately, clicking on Show Keyboard Layout will only display the English (US) keyboard layout. However, in case you need to manually select characters from a menu, you can use the Character Map application. This is generally installed by default on major Linux distributions. If not, you can find it in your respective Application Store.

Launching this application and selecting Sinhala under Scripts, will allow you to select and copy any Sinhala character to your clipboard.

With this, you can type in Sinhala.

LK-SLUG Sinhala Language Pack

However, there exists another method to set up Sinhala language support used in the past. This is the LK-SLUG language pack. This comes with fonts as well as the keyboard layout. However in my experience, for modern Ubuntu systems, this method is not that applicable. The layout is a bit different from the modern Sinhala layouts we find today such as Singlish, Phonetic and Wijesekara. But if required, this option is also available.

To install the LK-SLUG Sinhala language pack, enter the following command in the terminal.

sudo apt-get install fonts-lklug-sinhala ibus im-switch ibus-m17n m17n-db m17n-contrib language-pack-si-base

Enter your password if prompted and press enter. Once installed, you can log out; log back in and go to settings as we discussed before. If all goes well, you will see similar layouts under Add an Input Source including a few more options.

This will conclude the Sinhala language setup in modern Ubuntu systems. සිංහල භාෂාව සමඟ ඉදිරියට ලේඛන කරන ඔබට සුභ දවසක්.

References

• install sinhala unicode pack - AskUbuntu

• Sinhala unicode (Wijesekara keyboard) in iBus on Ubuntu 14.04 not working - AskUbuntu

• How to install WIjesekara Sinhala keyboard? - AskUbuntu

• Ubuntu සදහා සිංහල Install කරමු - පරිගණක ලිපි

• Sinhala input on Ubuntu 20.04 - Google Groups

• Helakuru Download

I have been a huge proponent of open-source software. Yet, I have always used Windows as my operating system. However, I tried several times to switch to Ubuntu, but they all failed due to a lack of experience and my workflows being too reliant on Windows. Times have changed and I find it even more important to switch to the Linux ecosystem.

When I first started, I found it hard to find any detailed resources for anyone willing to make the switch. However, with time I have acquired a substantial amount of experience on Linux and the project has improved quite a lot to accommodate new users; not to mention the ever-growing ecosystem of compatible software.

But Why Now?

There are several reasons why I wanted to take the decision. An important one is the fact that Windows has become more and more cluttered over time. I use Windows 11 and it feels so heavy on my hardware. Even after cleaning the hard disk and making sure not to have any virus or malware, the OS starts to feel laggy. With support for Windows 10 coming to an end soon; and the fact that I hate the aesthetics of Windows 10, I do not like to switch to Windows 10.

Another point to make is the interface design. Windows 11 is much better compared to the Windows 10 interface, however, I still find these inconsistencies not pleasing to the eye. Maybe I simply need a change to a different experience altogether. I have always loved the gnome interface and the new Ubuntu 23.10 design caught my eye. This is also a reason why I am willing to try again.

Windows XP and 7 were great operating systems at the time. But since then, Microsoft continued to disappoint. They've diverted into different business models that are harder and harder for me to keep up. With rumours of a subscription-based OS, it's not going to be affordable for me to continue using Windows. Overall, I don't find the philosophy behind Windows appealing anymore.

A Bit of Context

I have worked with Linux for quite a while now. Even my work laptop is running Linux and my office workflows have become completely reliant on Ubuntu. Still, my personal laptop had always been Windows. The biggest issue had been the workflows that I've been used to. Some of these require programs running only on Linux. On the other hand, I've been used to the interface since my childhood. Breaking these habits will need time.

The Approach

I have several key workflows that I follow. The first step would be to identify these workflows. This allows me to identify programs that require alternatives on Linux. Next would be to try replacing them on Windows itself. If not possible, I'll have to identify ways to run them on Linux.

Once This step is complete, I'll prepare the laptop by moving all my data out of the Windows partition into another partition and linking those paths to Windows libraries. This allows me to install Ubuntu into a new partition and share the data between both OS. This way, I will not run into document issues.

With both OS available, I'll try to move each workflow into Ubuntu. Once I'm confident that the transition is complete, I'll remove Windows completing the transition.

Final Thoughts

This is just an idea that I've been having for quite some time. The reason that I started this series is to document all the steps I follow in this journey. Maybe I might succeed, or maybe I won't, but either way, I have a feeling that some of the research I'll provide will be helpful to someone in the future. I don't have a deadline for this series and I prefer to take as much time as I require. Thus, I'm not sure when the next update will arrive. Until then...

Cheers 🎉

Before getting too carried away with the project, I wanted to do a bit of research on the platform that I'm dealing with. So I did a bit of research on the nRF development kits and the Nordic SoCs. The results I found were interesting and I wanted to share them.

The first is about nRF. I managed to get the nRF development environment up and running which I consider to be a huge milestone. The process was quite simple and required little to no effort. I simply followed the tutorial provided by Nordic themselves.

After this, my next plan was to get the blinky LED sample from Zephyr up and running. This was also not that complicated. I did follow a small tutorial which helped to understand what I'm doing, especially since I don't have prior experience with Zephyr. This worked out well and I had the LED blinking.

There are several ways to program the nRF board but I decided to go with the device tree and Zephyr OS method. This is much simpler and platform-independent which is ideal in my scenario.

In the next article, I plan to discuss a bit about the hardware design.

Until then... Cheers! 🎉

Reference

• Getting Started guide for nRF7002 DK

• Zephyr/nRF Blinky Tutorial

• Zephyr and nRF Connect SDK

• Zephyr: Tidbits

As you might already know, I have a project called Prometheus Fire Alarm System on GitHub. Prometheus is a next-generation fire alarm system Designed to take fire safety to the next level. This fire alarm system is designed to detect, indicate and extinguish fire by using necessary precautions.

Recently, I applied for a proposal for an improved version of Prometheus using the Matter Network and the Nordic Semiconductors nRF7002 Development Kit. The competition Make It Matter, is held by Nordic Semiconductors on the hackster.io platform. As I got selected among the 100 best proposals, I received an nRF7002 Development Kit to build a prototype of the project.

Fire Alarm System... Why?

Let's start with the obvious! One of the key requirements for a smart home is the safety and well-being of the inhabitants. This is why it's important to have devices to actively monitor and rectify any threats that occur within the house. One such threat is the hazard of fire. According to the WHO, more than 300,000 deaths occur every year due to fire-related hazards [1].

Thus we see the importance of incorporating a fire monitoring and extinguishing system into the modern smart home. This should actively monitor the environment for critical changes in the levels of humidity, temperature, and carbon dioxide and take necessary precautions to rectify any fires that get detected. The residents should also get the convenience of actively monitoring the state of the alarm and extinguishing system whenever they require it. This is the premise of the Prometheus Fire Alarm System v2.0.

Big Brother: Prometheus v1.0

This version aimed at developing a cost-effective monitoring and extinguishing system that is robust and scalable. The following were the targets of this project:

1. Cost - Develop a system based on off-the-shelf components that are cost-effective

2. Scalable - Availability for multiple monitoring devices to operate and synchronize in real-time

3. Independent - Whether connected or not, the device should monitor and react on its own without the involvement of the operator

There are four main sections and components for the proper functioning of the system. It will help to complete all the stages that are mentioned above.

1. Fire sensors

2. Extinguishing valves

3. Control unit

4. Software system

5. Structural design

This project was already completed and has been demonstrated to be effective. This demonstration is available under the following YouTube video.

What's Next?

The next step would be to improve the Prometheus Fire Alarm System into a smart home device, bringing in the cost-effective, independent, and scalable fire alarm and extinguishing system to the smart home. This will allow it to sit alongside other sensors and systems to provide all the smart homes with safety from fire.

The improvements thus suggested will be as follows.

1. Add a built-in charging system to allow the system to run when even the power is lost

2. Redesign the system to use the nRF7002 chip instead of an ATMega

3. Rewrite the firmware to incorporate the Matter protocol

What to Expect...

The reason why I started this devlog is to keep track of the progress of the project. I intend to follow a strict development timeline to make sure the final demonstration is ready in time. The biggest milestones are as follows.

In the next article, I will share some of the research I did on the nRF7002 Development Kit and the Matter Network.

Until then... Cheers! 🎉

Some Further Resources

• Prometheus Fire Alarm System Firmware Repo

• Prometheus Command Panel Repo

• Prometheus Fire Alarm System v1.0 Report

• Prometheus Fire Alarm System Demo Video (Youtube)

References

1. Deaths resulting from residential fires and the prevalence of smoke alarms--United States, 1991-1995

2. nRF7002 DK Reference

3. Matter Specification

4. Nordic Semiconductor Homepage

A Beowulf cluster is a type of High-Performance Computing (HPC) cluster that is designed to perform parallel computations on large data sets or complex computational problems. It is named after the legendary warrior Beowulf, who is known for his strength and ability to overcome seemingly insurmountable challenges.

The main feature of a Beowulf cluster is that it is created by using all the open-source resources available. Beowulf clusters are typically built using commodity hardware components: such as standard x86-based processors, Ethernet switches, and network interface cards. The nodes in a Beowulf cluster are connected through a high-speed local area network (LAN), which allows them to communicate and share resources efficiently.

One of the key features of a Beowulf cluster is its ability to distribute computing tasks across multiple nodes in parallel, allowing for faster processing times and improved performance. This is achieved through the use of a Message-Passing Interface (MPI), which allows nodes to communicate and coordinate their efforts in executing complex computations.

Beowulf clusters are commonly used in scientific research, engineering and other fields where large-scale computational tasks are required. They can be used to simulate complex physical processes, analyze massive data sets, and perform other computationally intensive tasks that would be impractical or impossible to perform on a single machine.

Overall, Beowulf clusters represent a powerful and cost-effective solution for high-performance computing, allowing organizations to harness the power of parallel computing to solve complex problems and drive innovation. Implementing a Beowulf cluster involves several steps, including hardware selection, software configuration, and network setup.

2. Hardware Selection

The hardware components required to follow this tutorial are as follows.

• More than one x86-based computer (these can be low-powered)

• A router/switch with enough ethernet ports and cables to connect all the computers and internet access

• A monitor, keyboard and optionally a mouse

• USB Stick (At least 8GB)

• A separate computer for setting up the cluster

To make this tutorial the below components are used. It is not essential to use exactly these items but these are mentioned simply to get an idea of how to choose these components.

• Three 64-bit HP desktop computers with 4GB of RAM, CPUs with four cores at 1.5 GHz and a hard disk of 500GB

• ADSL router with four ethernet ports

• Dell monitor and Logitech keyboard

• 8GB USB stick

3. Choosing an Operating System

In the very definition of a Beowulf cluster, it is mentioned open source software. Thus, it is essential to use an open-source operating system such as Linux to run on these computers. The most common OS used is Ubuntu Server although any of the available Linux OS would be suitable with slight variations of the software used and steps mentioned. In this example Ubuntu Server 22.04.2 is used however, other versions should also work with the above disclaimers.

4. Preparing for the Setup

Before starting to implement the cluster, a few things have to be taken care of. These are essential for the correct setting up of the cluster. Make sure to follow these steps carefully before moving further.

1. Setting up the Hardware

The first step is to set up the hardware correctly. This includes connecting the computers to the router via the ethernet cables. Pick one computer to be the master and the rest of the computers to be the slaves. The master computer or master node as referred to in Beowulf terms, is the computer that runs the program itself. This node breaks the process into multiple blocks and sends it to the slave computers or nodes to be processed. The router should be connected to the internet by suitable means. Internet connection is not essential for the operation of the Beowulf cluster but is only important for setting up the cluster.

The monitor, keyboard and optionally the mouse can be connected to the master node; however, note that these have to be removed and reconnected to the other computers as well.

2. Installing the Operating System

The best way to install the operating system on the hardware is to use a bootable USB stick. Use a separate computer and download the ISO of the installer of the preferred Linux OS, in the case of this tutorial, Ubuntu Server 22.04.2 is used as previously mentioned.

Also, download the Rufus bootable USB tool. In this example Rufus Version 3.22 (Build 2009) is used, however, the version number has little to no effect on the setup. Other bootable USB creators can also be used.

Open Rufus and choose the preferred USB device under Device. Then click on 'Boot Selection' and choose Disk or ISO image (Please select) and click on SELECT to choose the ISO file. Navigate to the ISO file and choose it. Other options should be left at default and click on START. For the warning, click OK although note that this process formats the pen drive and all data currently in it will be lost. For the next page, keep the defaults and click on OK as well. This will start the process of formatting the device into a bootable pen drive. Wait for this process to complete and remove the pen drive.

Next, we should install the OS on the hardware. For this, connect the pen drive to each computer one after the other and install the OS. In certain computers, when booting the OS in EFI mode will result in installation errors. In cases like this, try switching to Legacy BIOS before continuing with the installation. The steps involved might change from computer to computer on how to switch to 'Legacy mode' and how to enter the boot menu. Please refer online for the specific models.

The installation steps are normal. In all of the steps, the defaults will work fine. On each page, highlight the option Done. It is not essential to set up the network as this will be done in a future step. Downloading additional packages is also not necessary. Following the steps in this tutorial will be sufficient. In the Identity screen, however, under 'Your name:', 'Your server name:' and 'Pick a username:'; enter the following:

• 'master' for the computer you wish to use as the main computer of the cluster

• 'node1', 'node2', 'node3', etc. for the rest of the computers

It is not essential to follow this naming convention but will help identify the computers individually. For the 'Choose your password:' and 'Confirm your password:', enter a common password for all computers. This will help keep consistency although it's not essential to have the same password in all computers. Once the installation is complete, select Reboot. Every time the computers are turned on, enter the computer name and password to log in to the computers.

5. Setting up the Beowulf Cluster

1. Introduction

As mentioned before, the Beowulf cluster is a computer cluster made up of open-source components. Thus to set it up, the following components need to be set up in the computers.

• Message Passing Interface

• Network File System

• Hydra Process Manager

Make sure all the previous steps are followed correctly and that you have all of the computers ready with Ubuntu Server (or any other Linux distro) installed.

2. Setting Up the IP addresses

To continue, each computer must have a unique static IP address. For example, in our case, we will use the IP address of the master as 192.168.1.5, node1 as 192.168.1.6, node2 as 192.168.1.7, etc. It is not mandatory to use these exact IP addresses but using a consistent IP address assigning might come in handy. Make sure you remember which computer has which IP address.

To set up static IP addresses, first, make sure that all computers are correctly connected via ethernet to the router/switch. If this is confirmed, continue with the setup process. The below steps have to be performed on all the computers, thus disconnect and connect the keyboard and monitor to each computer and continue them.

1. Enter the command ip a on the terminal of each computer. This will list all the network interfaces connected to the computer. Find the one connecting the computer to the router/switch. Usually, this might be labelled as eno0, eno1, enp0s25 or eth0.

2. Once identified, move to the folder /etc/netplan. (Use the command cd /etc/netplan) Once in this folder, check if a file named 99_config.yaml or similar exists. (Use the command ls) If so open this using Nano or any other text editor. If it doesn't exist, create a file named 99_config.yaml. (Use the command sudo nano 99_config.yaml) Enter the below information in the file.

network:
  version: 2
  renderer: networkd
  ethernets:
    eno0:
      addresses:
        - 192.168.1.5/24
      routes:
        - to: default
          via: 192.168.1.1
      nameservers:
          search: [mydomain, otherdomain]
          addresses: [10.10.10.1, 1.1.1.1]

Under addresses:, include the IP address to be assigned for that particular computer. In this example, we've included the IP address we provided for the master. Under routes:, next to via:, include the IP address of the router. This is typically 192.168.1.1.

1. After completion, exit the text editor while saving the file. (Ctrl + X -> Y -> Enter for nano)

2. Use the command sudo netplan apply to apply the configuration.

3. On each computer, enter the command ping 192.168.1.5 where the IP address is to be replaced by the IP addresses of other nodes. Try for each node to each of the other nodes. If the configuration is correctly performed, you will receive a ping. If not, go through the steps and see if all of them are done correctly and that the network is set up correctly. A reason why this might fail is because the firewall refuses the connection. In that case, try disabling the firewall.

4. The next step is to add the hostnames to the hosts file. For this, move to the /etc folder. Edit the hosts file. Make sure the following hosts also exist in this file.

127.0.0.1       localhost
192.168.42.50   master
192.168.42.51   node1
192.168.42.52   node2

The IP addresses must match the IP address of the relevant node. Add all of the nodes you have here.

3. Creating the MPI User

A common user must exist across all computers to facilitate communication. For this reason, we will create a user called mpiuser across all the computers. This username as well as the UUID must be common to facilitate with the SSH authorization. Use the following command to create a user on all computers.

sudo adduser mpiuser --uid 999

If the UUID 999 is already taken, do the same command but with a different number. However, make sure that the same UUID is provided across all computers for this user. Also, make sure to include a number equal to or more than 999. Make sure to use a consistent password to avoid confusion. (Note that for certain commands, you might need to switch back to the main account; for example, commands that require sudo privileges. Entering the command exit will switch you back to the main account.)

4. Setting up the Network File System (NFS)

Network File System (NFS) is a distributed file system protocol that allows a user on a client computer to access files over a network as if those files were on the local computer. With NFS, a user can browse the remote file system, read and write files, and even execute programs located on the remote server. This makes it possible for multiple users to share files and collaborate on projects from different locations.

For this, the computers require an internet connection. If not, connect each computer to the internet and continue the steps. It is ok to disconnect the computers from the router/switch if required. Complete the steps and reconnect to the router/switch.

Use sudo apt-get update and sudo apt-get upgrade to get the app list and apps up to date. Then install NFS as explained below.

For the master node, enter the below command.

sudo apt-get install nfs-kernel-server

For the rest of the nodes, use the below command.

sudo apt-get install nfs-common

This will install the relevant NFS package on each computer.

5. Sharing the Home folder

Across all the computers, the /home/mpiuser directory has to be shared via NFS. For this, the /home/mpiuser directory has to be owned by the mpiuser. However, this folder is already created while adding the user, which means that the mpiuser already has access to it. To verify this, the following command can be used.

master:~$ ls -l /home/ | grep mpiuser

If the folder is already owned by the mpiuser, this should return a message similar to below.

drwxr-xr-x 7 mpiuser mpiuser 4096 May 30 05:55 mpiuser

If you want to share some other folder, use the below command on the master node with the specific folder you need to share.

sudo chown mpiuser:mpiuser /path/to/shared/dir

Now, the /home/mpiuser or any other folder created before the master node needs to be shared with the rest of the nodes. For this, the relevant folder needs to be added to the /etc/exports file. To do this, navigate to the /etc folder. (Use the command cd /etc) Now edit the file with the text editor (Use the command sudo nano exports) and add the following entry to it. This should only be done in the master node.

/home/mpiuser *(rw,sync,no_subtree_check)

Once done, save the file, (Ctrl + X -> Y -> Enter for nano) and then restart the NFS kernel using the below command.

sudo service nfs-kernel-server restart

To check if the folder is shared correctly, use the following command on the master node.

showmount -e master

If correctly performed, this should print the folder /home/mpiuser or the relevant folder on the terminal.

The next step is to check if it's accessible to the other nodes. Before that, we need to make sure the firewall doesn't block the communications between computers. For this, you can either disable the firewall or enter the following command on all computers. The IP address should be the gateway address. (*xxx.xxx.xxx.0/24)

sudo ufw allow from 192.168.1.0/24

Once complete, check the connectivity with the ping command used before.

Now, we can mount the shared folder on other nodes. For this, we use the below command on all nodes.

sudo mount master:/home/mpiuser /home/mpiuser

If this command hangs or fails, there's an issue with the configuration. If the command succeeds, test if the folder is shared across all nodes. For this, you can create a file in the /home/mpiuser directory of the master and see if it appears in the rest of the nodes. (Use the command touch hello to create a file)

If everything is correct so far, we have to set up the nodes to automatically mount this folder at boot. For this, move to the folder /etc/, (Use the command cd /etc/) then edit the file fstab on all computers. (Use the command sudo nano fstab) Add the below entry to this file.

master:/home/mpiuser /home/mpiuser nfs

Now reboot all computers and see if the system is correctly working, for example, the hello file is accessible from all nodes.

6. Setting up the Secure Shell (SSH)

SSH (Secure Shell) is a cryptographic network protocol that provides a secure way to access remote systems over an unsecured network. It was developed as a replacement for Telnet and other insecure remote shell protocols. To continue, SSH has to be set up on all computers.

Connect each computer to the internet and use the following command to install SSH.

sudo apt-get install ssh

Once done on all computers, SSH keys need to be generated under the mpiuser for all computers. Since the home folder is shared across all computers, these keys will be accessible to the master. On each computer, switch to the mpiuser, (Use the command su mpiuser) and then enter the following command.

ssh-keygen

When asked for a passphrase, leave it empty (hence passwordless SSH). Now switch to the master node and enter the following command under mpiuser.

ssh-copy-id localhost

If done correctly, you will get a message that says something similar to 'Number of key (s) added: 3'.

If configured correctly, now you might be able to SSH into any of the nodes from the master. Try to use the below command to enter into SSH from master to node1.

ssh node1

This should change the prompt from mpiuser@master:~$ to mpiuser@node1:~$ . This means that all commands executed will be executed inside of the mpiuser of node1. For example, the command echo $HOSTNAME, will print node1 instead of master. An advantage of this setup is that by using the command systemctl -i poweroff, you can shut down each computer remotely when SSH into the specific node. The same should apply to all other nodes.

7. Setup Hydra Process Manager

Hydra is a process management system used to manage and monitor processes on a Unix or Linux system. It is designed to be simple to use and can be used to start, stop, and monitor multiple processes at once. Hydra consists of two main components: a daemon process that runs in the background and a command-line interface that allows users to manage processes. The daemon process is responsible for starting and stopping processes, monitoring their status, and responding to commands from the command-line interface.

The Hydra Process Manager is included with the MPICH package, so we need to install MPICH on all computers. To do this, switch between each computer and use the following command to install it. To do this, make sure that the computer is connected to the internet.

sudo apt-get install mpich

This should install MPICH on all nodes. Once done, network all computers to the correct configuration and continue.

The next step is to configure MPICH. To do this, switch to the master and switch to mpiuser. (Use the command su mpiuser) Once in the mpiuser, move to the home directory. (Use the command cd ~) Now use a text editor to create a file called hosts, (Use the command nano hosts for nano) and enter the hostnames of the nodes you want the processes to run. You can either include the master node as a computer node or only use the other nodes. For example, refer to below. Once done, save the file. (Ctrl + X -> Y -> Enter for nano)

master
node1
node2

The above example will run the programs distributed across master, node1 and node2.

6. Running a Sample Program

1. Simple MPI Program in C

To write a simple MPI-based program in C, we will first create the source code. For this, we will switch to the mpiuser (Use the command su mpiuser) and move it into the home folder. (Use the command cd ~) Here, we will create a new file. (Use the command nano hello.c)

In it, we will write the following sample code.

#include <mpi.h>
#include <stdio.h>

int main(int argc, char** argv) {
    // Initialize the MPI environment
    MPI_Init(NULL, NULL);

    // Get the number of processes
    int world_size;
    MPI_Comm_size(MPI_COMM_WORLD, &world_size);

    // Get the rank of the process
    int world_rank;
    MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);

    // Get the name of the processor
    char processor_name[MPI_MAX_PROCESSOR_NAME];
    int name_len;
    MPI_Get_processor_name(processor_name, &name_len);

    // Print off a hello world message
    printf("Hello world from processor %s, rank %d out of %d processors\n",
           processor_name, world_rank, world_size);

    // Finalize the MPI environment.
    MPI_Finalize();
}

The code is designed to print the node names and their ranks on the terminal of the master.

The next step is to compile the code into an object file. For this, use the following command.

mpicc -o hello.o hello.c

This will compile the code into an object file. Now we can run the MPI program on the cluster. For this, enter the following code.

mpiexec -n 12 -f hosts hello.c

Here, -n 12 defines that the process should run on 12 threads and that -f hosts define the file which contains the list of nodes to run the program on.

If working correctly, it should print a result as below.

Hello world from processor 1, rank 1 out of 12 processors
Hello world from processor 5, rank 5 out of 12 processors
Hello world from processor 3, rank 3 out of 12 processors
Hello world from processor 2, rank 2 out of 12 processors
Hello world from processor 8, rank 8 out of 12 processors
Hello world from processor 4, rank 4 out of 12 processors
Hello world from processor 6, rank 6 out of 12 processors
Hello world from processor 7, rank 7 out of 12 processors
Hello world from processor 9, rank 9 out of 12 processors
Hello world from processor 10, rank 10 out of 12 processors
Hello world from processor 12, rank 12 out of 12 processors
Hello world from processor 11, rank 11 out of 12 processors

2. Simple MPI Program in Python

It is also possible to run an MPI program on Python. For this, we will follow the same steps and create a source file, this time named hello.py. In it, we will write the following code.

from mpi4py import MPI

comm = MPI.COMM_WORLD
rank = comm.Get_rank()
name = MPI.Get_processor_name()

print('My rank is ', rank, ' and hostname is ', name)

Once done, save the file and use the following command to run the program.

mpirun -np 12 --hostfile hosts python3 hello.py

If you get an error that says that mpi4py library is not installed, install it. (under mpiuser, use the command pip install mpi4py) If you get an error that says something similar to Permission Denied, use the command chmod +rwx ~ under mpiuser to mark the home folder and its content as executable. Retry running the command again.

You should get an output similar to below.

My rank is 1 and hostname is master
My rank is 3 and hostname is master
My rank is 2 and hostname is master
My rank is 4 and hostname is master
My rank is 5 and hostname is node1
My rank is 6 and hostname is node1
My rank is 8 and hostname is node1
My rank is 9 and hostname is node2
My rank is 7 and hostname is node1
My rank is 10 and hostname is node2
My rank is 11 and hostname is node2
My rank is 12 and hostname is node2

7. Conclusion

In conclusion, a Beowulf cluster is a type of high-performance computing cluster that is built from commodity hardware and is designed to run parallel computing applications. The Beowulf cluster architecture is based on a master-slave model, where a central master node manages the workload and distributes tasks to multiple slave nodes.

MPI (Message Passing Interface) is a standard interface for programming parallel applications on a Beowulf cluster. It allows processes to communicate with each other and synchronize their actions across multiple nodes. MPI provides a set of standard libraries and functions that can be used to develop scalable and efficient parallel applications.

Together, a Beowulf cluster and MPI provide a powerful platform for running large-scale parallel applications. They can be used for a wide range of applications, including scientific simulations, data processing, and machine learning. The scalability and flexibility of these systems make them an ideal choice for organizations and research institutions that require high-performance computing capabilities.

8. Reference

• https://ubuntu.com/server/docs/network-configuration

• https://mpitutorial.com/tutorials/mpi-hello-world/

• https://stackoverflow.com/questions/32257375/how-to-run-a-basic-mpi4py-code

• https://www.open-mpi.org/doc/current/man1/mpirun.1.php

• https://www.programcreek.com/python/example/89108/mpi4py.MPI.Get_processor_name

• https://rabernat.github.io/research_computing/parallel-programming-with-mpi-for-python.html

• http://cs.boisestate.edu/~amit/research/beowulf/lab-notes/node19.html

• https://github.com/jbornschein/mpi4py-examples

• https://gist.github.com/arifsisman/bcb6409fcb6150099cb8ddd044e28060

• https://rabernat.github.io/research_computing/parallel-programming-with-mpi-for-python.html

• https://blogs.cisco.com/performance/tree-based-launch-in-open-mpi

• https://blogs.cisco.com/performance/tree-based-launch-in-open-mpi-part-2