Here’s a simple and direct guide to properly install Toolbox on Linux Mint (and it works the same for Ubuntu/Debian in general).

1. Download the Toolbox​

Go to the official JetBrains website and download the latest .tar.gz file.

Assuming it was downloaded to ~/Downloads, extract it with:

cd ~/Downloads
tar -xvf jetbrains-toolbox-<version>.tar.gz -C ~/.local/

This will create something like:

~/.local/jetbrains-toolbox-<version>/

⚠️ Important: > Do not extract it inside ~/.local/share/JetBrains/Toolbox/. That folder is used by the app itself to store data and settings. The downloaded binary should stay in a separate directory, such as ~/.local/.

2. Run It for the First Time​

Navigate to the extracted directory and run the app:

cd ~/.local/jetbrains-toolbox-<version>/
./jetbrains-toolbox

Here’s what happens the first time you run it:

• It creates internal folders in ~/.local/share/JetBrains/Toolbox/
• It automatically generates a .desktop shortcut in ~/.local/share/applications
• From then on, JetBrains Toolbox appears in your system menu (Mint Menu / Application Menu)

3. Updates​

The Toolbox updates itself automatically. You don’t need to repeat this process every time a new version is released.

JetBrains Toolbox is designed to run entirely inside the user’s directory (~/.local), so it doesn’t require root privileges or system-wide installation.

Once installed, it takes care of everything — shortcuts, updates, and maintenance.

Install it at once and forget about it.

The Common Problem​

How many times have you gone through this frustrating situation?

1. You enable WiFi debugging on your device
2. You scan the QR code (or enter the pairing code) in Android Studio
3. It works for a while — until you restart the device or switch networks
4. Then you lose the connection and have to repeat the entire process
5. Or sometimes the QR code simply refuses to work

Wi-Fi debugging in Android Studio, when properly configured, offers a smoother and more productive development experience.
The key is understanding the difference between pairing and debugging ports, and using the adb pair command to create a persistent trust link between your device and your computer.

Following this guide, you’ll never need to scan QR codes again or deal with unstable connections.
The command-line pairing process is faster, more reliable, and gives you full control over the connection.

The Definitive Solution​

Prerequisites​

Before you start, make sure that:

• Android Studio is installed and ADB is properly configured
• Developer options are enabled on your device ¹
• Your computer and device are on the same Wi-Fi network
• Your phone has a static IP address configured ²

Step 1: Enable Wireless Debugging​

1. On your Android device, go to Settings > Developer options
2. Enable “Wireless debugging”
3. Tap “Wireless debugging” to open its settings
4. Tap “Pair device with pairing code”

You’ll see a screen like this:

Note: Two important pieces of information appear here:

• Pairing code (e.g., 817324)
• IP address and pairing port (e.g., 192.168.18.3:39233)

Step 2: Pair via Terminal​

Open your terminal (or Command Prompt on Windows) and run:

adb pair 192.168.18.3:39233

Important: Use the pairing port, not the debugging port!

The system will ask for the pairing code:

Enter pairing code: 817324
Successfully paired to 192.168.18.3:39233 [guid=adb-XXXXXXXXX]

Step 3: Connect for Debugging​

After pairing, the popup will close. Now take note of the debugging port shown on your device:

Connect using the debugging port (in my case, 36541):

adb connect 192.168.18.3:36541

Expected output:

connected to 192.168.18.3:36541

Step 4: Verify the Connection​

Check if your device is connected:

adb devices

Expected result:

List of devices attached
192.168.18.3:36541      device

Why This Works​

Trusted Connection​

The adb pair command establishes a cryptographically trusted link between your computer and your Android device. This trust relationship is persistent and doesn’t need to be repeated every time.

Port Difference​

• Pairing port: Used once to establish trust
• Debugging port: Used for all future sessions

Automatic Reconnection​

After the first pairing, Android Studio can:

• Automatically detect the device on the network
• Reconnect without a manual input
• Keep the connection much more stable

Benefits of WiFi Debugging​

• Freedom of movement: No cables restricting your workspace
• Real-world testing: Device operates normally while debugging
• Multiple devices: Connect and debug several devices simultaneously
• USB port preservation: Save wear on your computer’s USB ports

Additional Resources​

• Official ADB Documentation
• Android Studio Debugging Guide
• Developer Options on Android

So, I was trying to install Battlefield 2042 and found out that the latest update requires Secure Boot to be enabled.
No big deal — I use dual boot (Zorin OS for work, Windows 10 for gaming), so I jumped into my X99 Qiyida D4 BIOS and enabled Secure Boot.

The result?
Linux completely refused to boot and instead displayed this lovely message:

“Invalid signature detected. Check Secure Boot policy in Setup”

Great. Here we go again...

The Problem​

The GRUB that comes with Zorin (and pretty much any other distro) doesn’t have a valid digital signature for Secure Boot.
So the firmware looks at it and basically says:

“Don’t know you. Don’t trust you. Not loading you.”

…and that’s it — your boot stops right there.

The Solution​

Good news: you don’t need to disable Secure Boot forever or mess around with custom keys.
All you need to do is reinstall GRUB using the officially signed packages.
It’s quick and painless.

🧩 Step 0 — Temporarily Disable Secure Boot​

Yeah, sounds ironic, but you need to turn Secure Boot off for now.
If it stays on, GRUB won’t load, and you can’t fix anything.

Step 1 — Update Your System​

sudo apt update

Step 2 — Install the Correct Packages​

sudo apt install grub-efi-amd64-signed shim-signed

Step 3 — Reinstall GRUB​

sudo grub-install --target=x86_64-efi --efi-directory=/boot/efi --bootloader-id=grub

Step 4 — Update the Configuration​

sudo update-grub

Step 5 — Reboot and Re-enable Secure Boot​

Go back into your BIOS, turn Secure Boot back on — and boom 💥 GRUB will now load without any complaints.

Why This Works​

• grub-efi-amd64-signed → the “officially signed” GRUB, recognized by the firmware
• shim-signed → acts like a translator: the system trusts it, and it trusts GRUB
• Reinstalling ensures the proper configuration for UEFI + Secure Boot mode

The Result​

Now I can:

• Keep Secure Boot enabled (Battlefield’s happy)
• Use Zorin OS for work without issues
• Enjoy a slightly more secure setup — not that I really care 😅

All of this without dealing with custom keys, manual certificates, or 30-step guides. Just a clean, simple fix that works.

Before​

Into this 👇

After​

What Is GRUB?​

For those unfamiliar, GRUB is a boot manager that comes by default with most Linux distributions.
It’s essential if you use dual boot — that’s when you run more than one operating system (like Linux and Windows) on the same computer.

If you’re dual-booting without a boot manager, switching systems can be a nightmare — you’d have to open your BIOS every time and manually change the boot order.
With GRUB (or any boot manager), you can visually select which OS to start; no BIOS trips are required.

Why Customize GRUB?​

• 🎨 Pure aesthetics – Who said dual boot has to be ugly?
• 🔍 Visual clarity – identify each OS at a glance ¹
• 🚀 Style points – Because a slick boot screen says “this machine belongs to someone serious”

Downloading a Theme​

Enough theories — let’s jump to the fun part: finding a theme you like.
Head to the GNOME-Look GRUB Themes section:

👉 GNOME-Look — GRUB Themes

That site has tons of GRUB themes.
My personal favorite is this one: Star Rail Theme, which includes multiple subthemes — I’m currently using the Anaxa version.

Installing the Theme​

Before you mention it — yes, I know about GRUB Customizer,
but we’re doing it the proper way via terminal because it’s simpler and cleaner.

Using the Star Rail Theme as an example:
Click Download, choose the version you like (Anaxa.tar.gz in my case), and extract it — it’s a GZIP file that contains all theme assets.

Once extracted, you’ll get a folder like this:

Anaxa
├── background.png
├── icons
│   ├── ......
│   ├── windows11.png
│   ├── windows.png
│   └── zorin.png
├── select_c.png
├── select_e.png
├── select_w.png
└── theme.txt

Basically, a theme is a folder with images and one main file — theme.txt — that defines layout and asset positioning.

Step 1 — Create the GRUB Theme Folder​

If it doesn’t already exist:

sudo mkdir -p /boot/grub/themes/

Step 2 — Copy the Theme​

sudo cp -r Downloads/Anaxa /boot/grub/themes/

Step 3 — Check Your Screen Resolution​

Run this command to get your monitor’s resolution:

xdpyinfo | awk '/dimensions/ {print $2}'

It should return something like 1920x1080.

Step 4 — Configure GRUB​

Open the GRUB configuration file:

sudo nano /etc/default/grub

Find or add this line (replace Anaxa with your theme name):

GRUB_THEME="/boot/grub/themes/Anaxa/theme.txt"

Then scroll down and find this block:

# The resolution used on graphical terminal
# note that you can use only modes which your graphic card supports via VBE
# you can see them in real GRUB with the command `vbeinfo'
# GRUB_GFXMODE=auto

Uncomment and set the correct resolution you got earlier:

GRUB_GFXMODE=1920x1080

Save and exit (CTRL+X, then Y, then Enter).

Finally, update GRUB so it applies the new settings:

sudo grub-mkconfig -o /boot/grub/grub.cfg

Restart your computer, and voilà — your new stylish GRUB should appear:

Ignore the small “Anaxa” label in the bottom-right corner — that’s just part of the theme preview.

Edit Note​

I forgot to mention it — Ventoy also uses GRUB under the hood, so it’s totally possible to theme it too. Maybe I’ll cover that in a future post. Oh, and I’ll probably update the Star Rail theme link to the GitHub version later.

• Installing Hyper.js
• Configuring the Catppuccin Theme
• Installing Zsh
• Installing Oh My Zsh
• Installing ZInit
• Installing the Fira Code Font
• Installing Spaceship
• Preview
• Useful Links

For reference, I used Zorin OS Core (fresh install) while writing this tutorial.

Installing Hyper.js​

Hyper.js, or simply Hyper, is a terminal built with Electron — but here’s the catch: it’s beautiful, extensible, cross-platform, and extremely easy to configure.
Basically, the same setup works on all your machines. I absolutely love it.

To install it, visit the official website and click Download, or scroll down to pick the right package for your OS:

Once installed, open Hyper — it should look like this by default:

Configuring the Catppuccin Theme​

Catppuccin is a gorgeous theme — perfect if, like me, you’ve grown tired of using Dracula everywhere.
It’s not mandatory for this tutorial, but I highly recommend it.
Like Dracula, Catppuccin has ports for tons of tools. You can check them out at Catppuccin Ports.

To install it, open your Hyper configuration file:

nano ~/.hyper.js

Add the following under the plugins section:

{
  "plugins": ["hypurr#latest"]
}

Catppuccin comes in four color palettes:

• Latte
• Frappé
• Macchiato
• Mocha

Choose your favorite and add this line to your config:

module.exports = {
  config: {
    catppuccinTheme: "Macchiato", // <===== Add this
    ...
  },
  ...
}

Now your terminal should look something like this with the Macchiato theme:

Installing Zsh​

Up to this point, we’ve been working mostly on style. Now let’s make the terminal powerful using Zsh — an interactive shell that’s also a robust scripting language. It brings features from Bash and other shells, plus lots of improvements.

Install it with:

sudo apt install zsh -y

Check if it installed correctly:

zsh --version

You should see something like zsh 5.8.1 (x86_64-ubuntu-linux-gnu).

To make Zsh your default shell:

chsh -s /usr/bin/zsh

Then log out and back in for the change to take effect.

If you see this screen, just type 2 and press Enter:

Installing Oh My Zsh​

Oh My Zsh (or just OMZ) is a framework that makes Zsh configuration much easier — and the official site description is pretty funny 😆.

First, make sure you have curl and git installed:

sudo apt install curl git -y

Then, install Oh My Zsh:

sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

You’ll instantly notice how much prettier it looks. Also, take a look at the ~/.zshrc file — it’s similar to .bashrc or .profile. If you keep your aliases in another file (like .profile), just add this line anywhere in .zshrc:

source ~/.profile

Installing ZInit​

ZInit is a flexible and fast plugin manager for Zsh. It makes installing plugins effortless.

Install it with:

bash -c "$(curl --fail --show-error --silent --location https://raw.githubusercontent.com/zdharma-continuum/zinit/HEAD/scripts/install.sh)"

Accept the prompts with y and Enter.

Now, to add some essential plugins, open ~/.zshrc and add these lines at the end:

zinit light zdharma/fast-syntax-highlighting
zinit light zsh-users/zsh-autosuggestions
zinit light zsh-users/zsh-completions

Close and reopen your terminal — ZInit will automatically install them.

Installing the Fira Code Font​

Fira Code is a free monospaced font with ligatures that make reading code easier and more pleasant. It doesn’t change your code — just how it’s rendered visually.

We’ll need it because the next step (Spaceship) looks better with it. Learn more about it on the Fira Code GitHub page.

Install it using:

sudo apt install fonts-firacode -y

To use it in Hyper, open the preferences (Menu → Edit → Preferences), which opens ~/.hyper.js. Then add Fira Code to your fonts:

module.exports = {
  config: {
    fontFamily: '"Fira Code", Menlo, "DejaVu Sans Mono", Consolas, "Lucida Console", monospace',
    ...
  },
  ...
}

Installing Spaceship​

Spaceship is a powerful Zsh prompt — it shows useful information like git status, runtime, and more, in a clean and aesthetic way.

It can make your terminal look like this:

Install it via ZInit by adding this to the end of your ~/.zshrc:

zinit light spaceship-prompt/spaceship-prompt

Now configure it by appending this block to the same file:

SPACESHIP_PROMPT_ORDER=(
  user
  dir
  host
  git
  hg
  exec_time
  line_sep
  jobs
  exit_code
  char
)
SPACESHIP_USER_SHOW=always
SPACESHIP_PROMPT_ADD_NEWLINE=false
SPACESHIP_CHAR_SYMBOL="❯"
SPACESHIP_CHAR_SUFFIX=" "

Restart your terminal, and ZInit will handle the rest.

Preview​

After all these steps, your terminal will be both beautiful and highly functional — with autocomplete, syntax highlighting, and more. Of course, you can add hundreds of other plugins using OMZ, ZInit, or Spaceship.

Here’s the final result on my setup:

Spaceship helps you know exactly where you are in your system, and yes — if you connect via SSH, it looks the same remotely. Pretty cool, right?

Useful Links​

• raftheunis87/hyperjs.md
• awesome-hyper
• Oh My Zsh Plugins

Before we begin, I should mention that I’m still a beginner in Android development — and yes, I still code on my phone! So it won’t be possible to show examples using Android Studio.

Hello, Android developers! 👋
Today we’re going to understand what fragments are and how they can transform the way we design interfaces in Android applications.

What Are Fragments?​

If you’re starting out in Android development, understanding fragments is essential.
They act as modular parts of an activity, providing flexibility and reusability.
Think of them as LEGO pieces used to build dynamic interfaces.

Setting Up Dependencies​

Before diving into fragments, we need to configure some dependencies.
Add the Google Maven repository to your top-level build.gradle file:

dependencyResolutionManagement {
  repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
  repositories {
      google()
  }
}

Then, add the fragment-ktx dependency in your module’s build.gradle file:

dependencies {
  implementation("androidx.fragment:fragment-ktx:1.5.5")
}

Creating the Fragment Layout​

Before implementing the class, let’s prepare the environment. Create a new layout named fragment_example.xml:

<LinearLayout xmlns:android="https://schemas.android.com/apk/res/android"
              android:layout_width="match_parent"
              android:layout_height="match_parent"
              android:gravity="center"
              android:orientation="vertical">

    <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Fragment Example"
            android:textColor="@android:color/white"
            android:textSize="22sp"
            android:textStyle="bold"/>

</LinearLayout>

Now, define where the fragment will appear in your main layout (activity_main.xml) using FragmentContainerView:

<LinearLayout xmlns:android="https://schemas.android.com/apk/res/android"
              android:layout_width="match_parent"
              android:layout_height="match_parent"
              android:gravity="center"
              android:orientation="vertical">

    <androidx.fragment.app.FragmentContainerView
            android:id="@+id/fragment_container"
            android:layout_width="match_parent"
            android:layout_height="match_parent"/>

</LinearLayout>

Creating the Fragment Class​

Finally, let’s create the fragment class by extending Fragment and overriding the onCreateView method:

import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup

class ExampleFragment : Fragment() {
  override fun onCreateView(
    inflater: LayoutInflater,
    container: ViewGroup?,
    savedInstanceState: Bundle?
  ): View {
    return inflater.inflate(R.layout.fragment_example, container, false)
  }
}

A More Concise Alternative​

A cleaner and shorter way to define a fragment is:

import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.View

class ExampleFragment : Fragment(R.layout.fragment_example) {
  override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
    super.onViewCreated(view, savedInstanceState)
  }
}

This approach removes the need to override onCreateView(). I’ve seen many tutorials that put logic inside onCreateView(), but that’s not ideal. It’s better to use onViewCreated() since it’s called after the fragment is attached to the activity and the layout is inflated. Learn more about the Fragment lifecycle

Attaching the Fragment to an Activity​

There are two ways to attach a fragment to the container defined in activity_main.xml: via XML or programmatically.

Via XML​

To attach it directly in XML, use the android:name attribute to specify the fragment’s path — in this example, com.example.example.ExampleFragment:

<LinearLayout xmlns:android="https://schemas.android.com/apk/res/android"
              android:layout_width="match_parent"
              android:layout_height="match_parent"
              android:gravity="center"
              android:orientation="vertical">

    <androidx.fragment.app.FragmentContainerView
            android:id="@+id/fragment_container"
            android:name="com.example.example.ExampleFragment"
            android:layout_width="match_parent"
            android:layout_height="match_parent"/>

</LinearLayout>

Programmatically​

To attach a fragment programmatically, use a FragmentTransaction in your activity:

val fragment = ExampleFragment()
val fragmentTransaction = supportFragmentManager.beginTransaction()

fragmentTransaction.add(R.id.fragment_container, fragment)
fragmentTransaction.commit()

For better management, you can create a function to handle fragment transactions:

package com.example.example

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import androidx.fragment.app.Fragment

class MainActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    if (true) changeFragment(ExampleFragment())
    else changeFragment(Example2Fragment())
  }

  private fun changeFragment(fragment: Fragment) {
    val fragmentTransaction = supportFragmentManager.beginTransaction()
    fragmentTransaction.add(R.id.fragment_container, fragment)
    fragmentTransaction.commit()
  }
}

Fragments are key parts for creating reusable and robust interfaces in Android development. Experiment, improve your skills, and start building dynamic UIs! 🚀👩‍💻👨‍💻

I hope this guide adds a little bit of magic to your Android development journey. Happy coding! 👩‍💻👨‍💻

Types of Data Structures​

The most common examples are lists, stacks, queues, trees, and graphs. In the examples below, I’ll use arrays as a base.

Lists​

A list is a collection of values organized in an ordered sequence. In JavaScript, a list is an Array. An array is an invaluable data structure when you need to store and manage a collection of items in an ordered way. It offers many useful operations to manipulate these items, such as adding or removing elements, searching for a specific item, etc.

In general, you should use an array when you need to store and manage a collection of values and want fast access to them through numeric indices.

Example:

// Create an empty list
const list = [];

// Add elements to the list
list.push(1); // adds 1 to the end of the list
list.unshift(2); // adds 2 to the beginning of the list

// Remove elements from the list
list.pop(); // removes the last element from the list
list.shift(); // removes the first element from the list

// Access list elements
console.log(list[0]); // prints the first element in the list

// Search for elements in the list
console.log(list.indexOf(1)); // prints the index of element 1 in the list

// Sort elements in the list
list.sort(); // sorts the list elements in ascending order

Stack​

A stack is a structure that follows the rule “Last In, First Out” (LIFO), meaning the last item added to the array will be the first one removed.

Stacks are very common in programming languages and widely used in applications, such as undoing actions in code editors, browser navigation (when you go back to the previous page), among others.

Below is an example of a stack implementation in JavaScript:

class Stack {
  constructor() {
    this.items = [];
  }

  push(item) {
    this.items.push(item);
  }

  pop() {
    return this.items.pop();
  }

  peek() {
    return this.items[this.items.length - 1];
  }

  isEmpty() {
    return this.items.length === 0;
  }

  size() {
    return this.items.length;
  }
}

Queue​

A queue is the opposite of a stack because it follows the rule “First In, First Out” (FIFO), meaning the first item added is the first one removed.

Queues are very common in customer service systems, such as in banks, gas stations, or supermarket lines. They’re also widely used in many applications, such as background task management and event handling.

Example of a queue implementation in JavaScript:

class Queue {
  constructor() {
    this.items = [];
  }

  enqueue(item) {
    this.items.push(item);
  }

  dequeue() {
    return this.items.shift();
  }

  peek() {
    return this.items[0];
  }

  isEmpty() {
    return this.items.length === 0;
  }

  size() {
    return this.items.length;
  }
}

Trees​

A tree is a bit more complex than the others. It’s a hierarchical data structure consisting of nodes and branches. Each node can have one or more children but only one parent. The very first node of the tree is called the root, and nodes without children are called leaves.

This structure is very useful and widely used in applications such as representing file system structures, implementing search trees, and representing hierarchical relationships in databases.

Example of a tree implementation in JavaScript:

class TreeNode {
  constructor(value) {
    this.value = value;
    this.children = [];
  }
}

class Tree {
  constructor() {
    this.root = null;
  }
}

const tree = new Tree();
const root = new TreeNode(1);
const left = new TreeNode(2);
const right = new TreeNode(3);

root.children.push(left, right);
tree.root = root;

Graphs​

A graph in data structures is composed of vertices (also known as nodes) and edges. Each vertex can have a set of edges that connect it to other vertices. The edges can be directed (meaning they have a direction) or undirected (meaning they don’t). Graphs are used to represent relationships between elements in a dataset and are useful for solving the shortest path problems, representing networks, and modeling complex systems. See more

Here’s an example of an undirected graph in JavaScript:

class Graph {
  constructor() {
    this.nodes = [];
    this.edges = [];
  }

  addNode(node) {
    this.nodes.push(node);
  }

  addEdge(node1, node2) {
    this.edges.push([node1, node2]);
  }
}

const graph = new Graph();
const node1 = "A";
const node2 = "B";
const node3 = "C";

graph.addNode(node1);
graph.addNode(node2);
graph.addNode(node3);
graph.addEdge(node1, node2);
graph.addEdge(node2, node3);

In this example, we have a Graph class that represents the entire graph. The graph has an array of nodes and an array of edges. We added three nodes to the graph and two edges connecting them, resulting in the following structure:

A -- B -- C

Here’s an example of a directed graph in JavaScript:

class DirectedGraph {
  constructor() {
    this.nodes = [];
    this.edges = [];
  }

  addNode(node) {
    this.nodes.push(node);
  }

  addEdge(node1, node2) {
    this.edges.push([node1, node2]);
  }
}

const graph = new DirectedGraph();
const node1 = "A";
const node2 = "B";
const node3 = "C";

graph.addNode(node1);
graph.addNode(node2);
graph.addNode(node3);
graph.addEdge(node1, node2);
graph.addEdge(node2, node3);

In this example, we have a DirectedGraph class representing a directed graph. It’s the same as the previous example, except that the edges are directed — meaning they have a defined direction. This gives us the following structure:

A -> B -> C

Other examples of graph usage include:

• Representing a computer network and finding the shortest path between two computers.
• Representing a transportation network and finding the fastest route between two locations.
• Representing a relationship network and finding the shortest path between two people.

Sources​

• Data structures
• The examples were created using ChatGPT because I was too lazy to code them by hand.
• Images: list, queue, stack, trees, graphs