As usual, we will start with the setup(). This is available in Pong.pde, the project's main file.

void setup() {
    size(1000, 600);
    frameRate(60);

    PFont font = loadFont("font.vlw");
    textFont(font);

    rectMode(CENTER);

    player_one = new Paddle("1", 100, height / 2, 0, height, 10, 100);
    player_two = new Paddle("2", width - 100, height / 2, 0, height, 10, 100);

    ball = new Ball(width / 2, height / 2, 10, 10, width, height);
    ball.reset();
}

This is pretty standard: Set the canvas size, frame rate, load fonts, set the rectangle mode and set up the objects for the players and ball. I have discussed loading the fonts in the previous article, so I will not go through it here. You can also refer to the GitHub repo for the instructions.

The font I chose was Bitwise Font by Digital Graphics Labs. You can find it at www.fontspace.com.

The draw() function is also quite simple.

void draw() {
    background(0);
    backgroundDraw();

    render();

    if (!pause) {
        update();
    }
}

We first draw a black background, draw the background items and then render the dynamic items. If we're not on pause, we also update the physics.

The keyPressed() function is also quite simple.

void keyPressed() {
    if (key == 'w') { player_one.up(); }
    if (key == 's') { player_one.dn(); }

    if (key == 'p') { player_two.up(); }
    if (key == 'l') { player_two.dn(); }

    if (key == 'r') { reset(); }

    if (key == ' ') {
        if ((player_one.score(0) > over) || (player_two.score(0) > over)) {
            reset();
        }

        pause = !pause;
    }
}

Pressing the keys w and s will move player one up and down. p and l for player two. r will reset the game, and the space will reset the game if either player has completed the scores, and pause either way. mousePressed() is also the same as pressing the space.

void mousePressed() {
    if ((player_one.score(0) > over) || (player_two.score(0) > over)) {
        reset();
    }

    pause = !pause;
}

Background draw is long, but it pretty much does some basic shape drawing as well.

void backgroundDraw() {
    fill(255);

    rect(width / 2, height / 2, 5, height);

    textAlign(CENTER, CENTER);
    textSize(32);

    text(player_one.score(0), 50, 100);
    text(player_two.score(0), width - 50, 100);

    if (pause) {
        if ((player_one.score(0) > over) || (player_two.score(0) > over)) {
            String p = "1";
            if (player_two.score(0) > over) {
                p = "2";
            }

            text("GAME   OVER\n   PLAYER " + p + "      HAS  WON\n   CLICK OR PRESS   SPACE TO START", width / 2, 400);
        } else {
            text("PO  NG\n   CLICK OR PRESS   SPACE TO START", width / 2, 400);
        }
    }
}

The colour we use for drawing is white. We first draw a divider in the centre of the screen. Then we draw the scores of each player. If paused, we also draw some text on the screen. If either of the player has exceeded the winning score, we display the winner; if not, we show instructions to play the game.

reset() and render() also perform similar functions.

void reset() {
    ball.reset();

    player_one.reset();
    player_two.reset();
}

void render() {
    ball.render();

    player_one.render();
    player_two.render();
}

We either reset or render the two players and ball.

update() function handles all the physics.

void update() {
    if (frameCount % 2 == 0) {
        int upd = ball.update();

        if (upd > 0) {
            if (upd == 1) { player_one.score(1); }
            if (upd == 2) { player_two.score(1); }

            if ((player_one.score(0) > over) || (player_two.score(0) > over)) {
                pause = true;
            }

            ball.reset();
        }
    }
}

Here, for every two frames, we perform a physics update. First, the ball is updated. It will return if either of the players scored. 0 means no score, and either 1 or 2 represents the player who scored. So, if we have a return greater than 0, we check if it's 1 or 2 and increase the score of the respective player. We also check if any of the players have reached the winning score and pause if so. We also reset the ball.

Now, we will move on to the next file: Game.pde. This has all the classes related to the ball and player.

The first one we will look at is the player: the Paddle class.

public class Paddle {
    private String id;

    private int start_x, start_y;

    private int x, y;

    private int width, height;

    private int up_x, dn_x;

    private int score = 0;

    private int SPEED = 10;
    
    public Paddle(String id, int x, int y, int up_x, int dn_x, int width, int height) {
        this.id = id;
        this.start_x = x; this.start_y = y;
        this.x = x; this.y = y;
        this.up_x = up_x; this.dn_x = dn_x;
        this.width = width; this.height = height;
    }

    public String id();
    
    public void render();

    public void reset();

    public void up();

    public void dn();

    public int score(int sc);
}

We have a few private variables that are quite simple. id holds a unique identifier for the player. start_x and start_y represent the initial positions of the paddle. x and y relate to where the paddle is now. width and height are the width and height of the paddle. up_ and dn_x are the limits when moving the paddle up and down. score is the score of the player, and SPEED is the speed of the paddle. The constructor sets these up.

id() returns the ID of the player.

public String id() {
    return id;
}

render() renders the paddle.

public void render() {
    fill(255);
    rect(this.x, this.y, this.width, this.height);
}

reset() resets the paddle to its initial position.

public void reset() {
    this.x = this.start_x; this.y = this.start_y;
    score = 0;
}

up() and dn() move the paddle up or down by the SPEED.

public void up() {
    if (this.y > up_x) {
        this.y -= SPEED;
    }
}

public void dn() {
    if (this.y < dn_x) {
        this.y += SPEED;
    }
}

score() will increase the score and return the current score.

public int score(int sc) {
    this.score += sc;

    return this.score;
}

The other class we have is the Ball class. This class will be used to create the ball object that will be rendered on the screen.

public class Ball {
    private int start_x, start_y;
    private int x, y;

    private int width, height;

    private int speed_x, speed_y;

    private int window_w, window_h;

    private int hits = 0;

    public Ball(int x, int y, int width, int height, int window_w, int window_h) {
        this.start_x = x; this.start_y = y;
        this.x = x; this.y = y;
        this.width = width; this.height = height;
        this.window_w = window_w; this.window_h = window_h;

        this.speed_x = 2 - (4 * round(random(0, 1))); this.speed_y = 2 - (4 * round(random(0, 1)));
    }

    public void reset();

    public void render();

    public int update();
}

The start_x and start_y variables hold the initial start position of the ball. x and y will hold the current position. width and height determine the size of the ball. speed_x and speed_y hold the current speed of the ball. window_w and window_h hold the total width and height of the screen. hits hold the number of hits the ball has with the paddles. The initialiser function handles setting up these variables. It also sets the speed to either direction randomly to create a sense of randomness when passing the ball.

The reset() function is also similar to the paddle. It just resets the position of the ball.

public void reset() {
    this.x = start_x; this.y = start_y;
}

render() is also the same. It just resets the ball to the initial position.

public void render() {
    fill(255);
    rect(this.x, this.y, this.width, this.height);
}

The update() function performs the physics-related tasks.

public int update() {
    this.x += this.speed_x; this.y += this.speed_y;

    if ((this.y <= this.height / 2) || (this.y >= this.window_h - (this.height / 2))) {
        this.speed_y = -(this.speed_y);
    }

    if (((this.x <= player_one.x) && (this.y >= (player_one.y - (player_one.height / 2))) && (this.y <= (player_one.y + (player_one.height / 2))))
    ||  ((this.x >= player_two.x) && (this.y >= (player_two.y - (player_two.height / 2))) && (this.y <= (player_two.y + (player_two.height / 2))))) {
        int speed_offset = 0;
        int speed_max = 0;

        if (this.x <= player_one.x) {
            speed_offset = this.y - player_one.y;
            speed_max = player_one.height / 2;
        } else {
            speed_offset = this.y - player_two.y;
            speed_max = player_two.height / 2;
        }

        this.speed_y = speed_offset * 5 / speed_max;
        this.speed_x = -(this.speed_x);
        hits++;

        if (hits % 4 == 0) {
            this.speed_x += (this.speed_x / abs(this.speed_x));

            if (this.speed_y == 0) {
                this.speed_y = 1 - (2 * round(random(0, 1)));
            }
        }
    } else {
        if (this.x < player_one.x) {
            return 2;
        } else if (this.x > player_two.x) {
            return 1;
        }
    }

    return 0;
}

The first thing this task does is move the ball at the speed. If the ball has reached the top or bottom of the screen, the speed in the y-axis is flipped to simulate a bounce. Next, it will check if the ball reached each of the paddle's x positions. If so, we check if we reached away from the paddle's surface. If so, we return the opposite paddle to which it reached the end to indicate a score for the opposing player. If not, we check in which region of the paddle we reached, and we update the y speed accordingly.

For example, if the ball reached the end of the paddle, the angle at which it reflects will be higher, and if it's in the middle, the ball will directly reflect. We will also oppose the x speed while also increasing the hit count. The reason why we keep track of the hits is that the classic arcade game used to increase the speed with every four hits. Here, we're doing the same thing.

This creates the classic arcade Pong game with almost similar mechanics.

The reason why I wanted to create this is that I have another idea I want to pursue with this project. I will post a follow-up article to this with the other ideas I have. Till then, enjoy... 👋

External Links:

• GitHub Repository with the Processing Code: Github Repository

• Wikipedia article on Pong: Pong

First step, of course, would be to find the correct font, obviously 😐. I checked several options, but the one that stood out for me was the font called Matrix Code NFI Font by Norfok Incredible Font Design. You can find it at www.fontspace.com.

I downloaded the font and converted it to be used in Processing. This is pretty straightforward. Just download the font, and you will get a zipped archive.

1. Extract the archive, and you will see a font file called MatrixCodeNfi-YPPj.otf inside.

2. Double-click and install this font to the system.

3. Create a folder titled data in the root folder of our sketch.

4. Open the Processing application.

5. Go to Tools -> Create Font....

6. Scroll through the list of fonts and select the font we just installed. (MatrixCodeNFI)

7. Change the filename to font.vlw.

8. Click on OK.

9. A file called font.vlw will be created in the data directory. If it's created somewhere else, copy it to the data directory.

Now that the fonts are ready, we will move on to the actual sketch. First, we'll start with some settings. Here, we will set up the canvas size, load the font, prepare the sizes and counts and create a copy of the charset.

void settings() {
  size(1800, 1000);
  font = loadFont("font.vlw");

  column_size = width/COLUMN_COUNT;
  row_size = column_size;
  row_count = ceil((height * 1.0) / row_size);
  text_size = column_size - (TEXT_OFFSET * 2);

  System.arraycopy(CHARACTER_SET, 0, characters, 0, CHARACTER_SET.length);
}

The column size is calculated with the width and number of columns we have defined to be included. I've also approximated the row size to be the column size. The number of rows is defined by the height and the size of the row that we're defined. Here, we take the ceiling to allow for an extra row below instead of keeping an empty row. This creates a seamless visual that spans the whole window.

I've also defined the CHARACTER_SET that will be used for text streaks. The set is as below.

char[] CHARACTER_SET = {
  '!',      '"',      '#',      '$',      '%',      '&',      '\'',
  '(',      ')',      '*',      '+',      ',',      '-',      '.',      '/',
  '0',      '1',      '2',      '3',      '4',      '5',      '6',      '7',
  '8',      '9',      ':',      ';',      '<',      '=',      '>',      '?',
  'A',      'B',      'C',      'D',      'E',      'F',      'G',
  'H',      'I',      'J',      'K',      'L',      'M',      'N',      'O',
  'P',      'Q',      'R',      'S',      'T',      'U',      'V',      'W',
  'X',      'Y',      'Z',      '[',      '\\',     ']',      '^',      '_',
  'a',      'b',      'c',      'd',      'e',      'f',      'g',
  'h',      'i',      'j',      'k',      'l',      'm',      'n',      'o',
  'p',      'q',      'r',      's',      't',      'u',      'v',      'w',
  'x',      'y',      'z',      '{',      '|',      '}',      '~'
};

This is copied to a temporary buffer called characters. The reason is that we intend to inject glitches into the streaks, which will be apparent later. This makes sure the original list stays intact without worrying about losing characters. Of course, you can modify the original character set according to your requirements and font.

Next, we will move into the setup.

void setup() {
  background(BACKGROUND);
  frameRate(FRAMERATE);
  textFont(font);

  for (int i = 0; i < (int)random(0, COLUMN_COUNT); i++) {
    buffer.add(new Streak((int)random(0, COLUMN_COUNT), (int)random(0, row_count)));
  }

  textSize(MESSAGE_SIZE);
  fill(STATIC);
  textAlign(CENTER);
  text(message, width/2, MESSAGE_Y);

  delay(MESSAGE_DELAY);
}

We set the background colour, set the frame rate, and set the text font. The hallmark feature of the digital rain animation is the streaks of characters that fall from the top of the screen. To define the behaviour of such a streak, we will define a class called a Streak. We will see how this works later. A critical feature is to have a buffer of such streaks to allow them to appear and disappear on the screen. To do this, we have a buffer variable that will hold the streaks that are visible on the screen at any given time. At the start, we will add a random number of streaks to the buffer at random x and y positions.

This is followed by the text size, defining a static font, aligning to the centre, and printing an initial message defined in message variable. This is followed by a delay. The message is as follows:

String message = "PRESS THE SPACE KEY TO EXIT THE MATRIX\nCLICK ANYWHERE TO GENERATE A GLITCH";

Before moving into the draw function, we will look at the Streak class. The structure is as follows:

public class Streak {
  private int x, y;
  private int cursor = (int)random(0, characters.length/2);
  private int lives = STREAK_LIVES;
  private int state = 0;
  private int floor = cursor;
  private int ceiling = (int)random(cursor + 1, characters.length);

  public Streak(int x, int y) {
    this.x = x; this.y = y;
  }

  public void draw();

  public boolean dead();

  private void draw_char(int j, color colour);
}

There are a few private variables defining the characteristics of the streak. The x, y coordinates, cursor position at the start, number of lives remaining, current state, floor and ceiling: which define the subset of characters from the main character set that are utilised in this streak.

I believe x and y are self-explanatory. Also, floor and ceiling. A streak has two main states: alive and dead. The alive state is when the streak is visible on the screen. Dead is when it disappears from the screen.

An alive streak will be in two main states: active and passive. The streak starts its life with the cursor at the first character of the sub-characters buffer. The lives will be at maximum and state will be 0. (alive) If you check the animation, a streak starts with nothing. Then one after the other, characters from the buffer appear one after the other until the end of its buffer is reached. The cursor is the last character displayed by the streak. Once it reaches the end of its buffer, the cursor is gone.

To emulate this, for each time the draw() function is called, we increase the cursor. When the end of the buffer is reached, we keep the cursor in place, but start decreasing the lives. This leaves the streak visible on the screen until the lives reach zero, at which point we change the state to 1. (dead) While the cursor is not at the ceiling, we draw the cursor or the last character currently visible on the buffer as white. The characters we print are from the floor to the cursor only. The rest of the visible characters are left as green. When the ceiling is reached, we display all characters as green. When dead, we do not print the characters.

You can see this behaviour in the following code snippet:

  public void draw() {
    if (this.state == 0) {
      if (this.cursor >= this.ceiling) {
        draw_char(this.cursor - 1, STATIC);
        this.lives--;

        if (this.lives <= 0) {
          this.state = 1;
        }
      } else {
        draw_char(this.cursor, CURSOR);
        this.cursor++;
      }

      for (int j = this.floor; j < this.cursor - 1; j++) {
        draw_char(j, STATIC);
      }
    }
  }

The dead() function is simply there to return whether the streak is dead or alive.

  public boolean dead() {
    return (this.state == 1);
  }

The draw_char() function draws the characters to the screen according to the logic we discussed under draw().

  private void draw_char(int j, color colour) {
    textSize(text_size);
    fill(colour);
    textAlign(CENTER);

    if (this.y + j >= row_count) {
      text(characters[j], (this.x * column_size) + (column_size / 2), (this.y + 1 + j - this.floor - row_count) * row_size);
    } else {
      text(characters[j], (this.x * column_size) + (column_size / 2), (this.y + 1 + j - this.floor) * row_size);
    }
  }

Now that we understand how the streaks work, we will move into one of the most critical functions of the code. The glitch() function.

void glitch() {
  for (int i = 0; i < character_glitch.length; i++) {
    if (character_glitch[i]) {
      characters[i] = CHARACTER_SET[(int)random(0, CHARACTER_SET.length)];
    }
  }

  if ((int)random(0, GLITCH_ENTROPY) == 4) {
    int pos = (int)random(0, character_glitch.length);
    character_glitch[pos] = !character_glitch[pos];
  }
}

The purpose of this function is to introduce glitches into the streaks. Remember we discussed that we need a separate copy of the original charset. This is why. We have a separate array which defines if each char in the charset is glitched.

char[] characters = new char[CHARACTER_SET.length];
boolean[] character_glitch = new boolean[characters.length];

What we do in the glitch() function is, we first go through each char of the characters. We check if the corresponding character_glitch is enabled or not. If a glitch is enabled, we glitch that specific character. IE, we pick a random character from the CHARACTER_SET and replace this character with that.

Next, we randomly pick some characters from the character_glitch and flip their state: stable or glitched. This is what creates the iconic glitching effect of the streaks.

Since each streak in the buffer is tied to the characters, when a glitch is introduced, this is visible across all streaks.

Next, we will move on to the draw() function. This is pretty straightforward.

void draw() {
  fill(BACKGROUND >> 16 & 0xFF, BACKGROUND >> 8 & 0xFF, BACKGROUND & 0xFF, FADE);
  rect(0, 0, width, height);

  if ((random(0, 10) < STREAK_ENTROPY) && (matrix)) {
    buffer.add(new Streak((int)random(0, COLUMN_COUNT), (int)random(0, row_count)));
  }

  for (int i = 0; i < buffer.size(); i++) {
    Streak streak = buffer.get(i);

    if (streak.dead()) {
      buffer.remove(i);
      i--;
    } else {
      streak.draw();
    }
  }

  glitch();
  
  drawTopic();
}

We first fill the screen with black accompanied by an alpha value. This allows the dead streaks to fade away smoothly. We also make sure to add some new streaks to the buffer to replenish any that have gone dead. Then for each streak, we remove it from the buffer if it's dead, and draw() it if it's alive. Then we introduce the glitch().

We also draw the topic using the drawTopic() function.

void drawTopic() {
  String topic_str = "";
  for (int i = 0; i < topic.length; i++) {
    topic_str += characters[topic[i]];
  }

  fill(0, 0, 0, TOPIC_FADE);
  rect(0, (TOPIC_Y / 2) + 5, width, TOPIC_SIZE);

  textSize(TOPIC_SIZE);
  fill(STATIC);
  textAlign(CENTER);
  text(topic_str, width/2, TOPIC_Y);
}

Notice how the topic is described by the position of each character of the text THE_MATRIX.

int[] topic = {50, 38, 35, 61, 43, 31, 50, 48, 39, 54};

When displaying, the text is reconstructed using the characters. This introduces the glitching effect to the topic too.

That is pretty much the guts of this demo. We also have two supporting functions.

void keyPressed() {
  if (key == PAUSE_KEY) {
    matrix = !matrix;
  }
}

Here, when the space bar is pressed, the matrix effect is paused; essentially stops spawning new streaks in the buffer. And vice versa if pressed again.

void mouseClicked() {
  int x = (mouseX * COLUMN_COUNT) / width;
  int y = (mouseY * row_count) / height;

  fill(STATIC);
  rect(x * column_size, y * row_size, column_size, row_size, 5);

  buffer.add(new Streak(x, y));
}

Also, when the mouse is clicked on the screen, using the x and y coordinates of the cursor, a new streak is created in that specific location.

Combined, this simple code creates an amazing and sophisticated visual effect created for the movie screen. You can tweak some of the parameters to see how that affects the animation.

External Links:

• GitHub Repository with the Processing Code: Github Repository

• Wikipedia article on Digital Rain: Digital Rain

• Reference animation: YouTube

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