Forem: Harry Tanama

Git Golden Rules

Harry Tanama — Sat, 13 Dec 2025 20:19:23 +0000

Golden Rules to help prevent your Git repository from breaking:

Golden Rule 1: Never Force Push

Avoid using git push -f or git push --force as it can overwrite other developers' changes and cause conflicts.
Instead, use git push origin main (or your remote branch name) to update the remote repository.

Golden Rule 2: Always Pull Before Pushing

Make sure to pull from the remote repository before pushing your local changes: + git pull origin main (or your remote branch name) + This ensures you have the latest updates and avoids merge conflicts.

Golden Rule 3: Merge Branches Regularly

When working on a feature or bug fix, create a separate branch for it.
Once you've completed your changes, merge that branch into the main branch using git merge (e.g., git merge feature/new-feature).
Resolve any merge conflicts by manually editing the files and adding them to the index with git add.

Golden Rule 4: Resolve Merge Conflicts Carefully

When resolving a merge conflict, use tools like git status, git diff, or meld to help identify the conflicting changes.
Manually edit the files to resolve the conflicts and then add them to the index with git add.
Make sure to test your code thoroughly after resolving a merge conflict.

Golden Rule 5: Test Thoroughly Before Committing

Run automated tests, manual testing, and code reviews to ensure your changes are correct and don't introduce new bugs.
Don't commit broken or incomplete code; it'll only cause more problems down the line!

Golden Rule 6: Use Meaningful Branch Names and Descriptions

Use clear and descriptive branch names (e.g., feature/new-feature instead of new-feature) to help track changes and collaborate with others.
Include a brief description or summary in your commit message to explain what's changed.

Golden Rule 7: Keep Commits Small and Focused

Avoid massive commits that make it difficult to understand what's changed.
Instead, break down large features into smaller, manageable commits (ideally <10 lines of code).

Golden Rule 8: Regularly Review and Clean Up Your Branches

Periodically review your branches to ensure they're up-to-date and aligned with the remote repository.
Delete old or unnecessary branches to keep your Git repository organized!

Additional Tips for Handling Merge Conflicts:

Use git merge --abort: If you encounter a conflict, use git merge --abort to cancel the merge and try again later.
Use git stash temporarily: If you need to make changes while resolving a merge conflict, use git stash to store your work and then continue working on the conflict.
Communicate with team members: Inform your teammates about any merge conflicts or difficulties you're experiencing so they can help resolve them.

By following these Golden Rules and handling merge conflicts carefully, you'll minimize the risk of breaking your Git repository and create a healthier collaborative environment for your team!

Communication is Key

When someone pushes changes to a branch that others are currently working on, it's essential to communicate with the team to prevent conflicts and ensure everyone has the latest updates. Here are some
steps you can follow:

Get notified: Set up notifications for your Git repository to alert you when someone pushes changes to the branch you're working on.
Pull the updated branch: As soon as you receive notification, pull the updated branch from the remote repository: git pull origin <branch-name>
Resolve conflicts (if any): If there are merge conflicts, resolve them manually and then add the resolved files to the index with git add.
Rebase your local changes: After pulling the updated branch, rebase your local changes on top of the latest updates: git rebase origin/<branch-name>
Test thoroughly: Verify that your code still works correctly after rebasing and resolve any issues.

Best Practices for Collaborative Development

To avoid conflicts and ensure smooth collaboration:

Use feature branches: Create separate branches for each new feature or bug fix to isolate changes.
Communicate with the team: Inform your teammates about your work on a particular branch, so they can plan their own updates accordingly.
Regularly pull from the remote repository: To ensure you have the latest updates and avoid merge conflicts.
Use Git hooks: Set up Git hooks to enforce coding standards, formatting, and other best practices.

Automating Notifications with GitHub

If you're using GitHub, you can set up notifications for your repository to alert team members when someone pushes changes to a specific branch:

Go to your repository settings
Click on "Notifications"
Select the branch you want to receive notifications for
Choose the notification type (e.g., push, pull request)

By following these best practices and communicating with your team, you'll be able to work efficiently and avoid conflicts when collaborating on codebases!

3 Ways to Create A Floor in Godot

Harry Tanama — Wed, 10 Dec 2025 02:38:47 +0000

There are so many ways to create game. There is no right or wrong way of creating a video game.

The first set up or method to create a floor in godot.
-MeshInstance3D
-StaticBody3D
-CollisionShape3D

The second set up or method to create a floor in godot is to use CSGBox3D and check the box "Use Collision" ON located on the Inspector.

The third set up method to create a floor in godot
-StaticBody3D
-MeshInstance3D
-CollisionShape3D

Arch Linux - How to Connect to Internet

Harry Tanama — Sun, 30 Nov 2025 20:00:06 +0000

iwctl - Internet wireless control utility

To connect to a network: .. code-block:

[iwd]# device list
[iwd]# station DEVICE scan
[iwd]# station DEVICE get-networks
[iwd]# station DEVICE connect SSID

$ iwctl device list
$ iwctl station DEVICE scan
$ iwctl station DEVICE get-networks
$ iwctl --passphrase=PASSPHRASE station DEVICE connect SSID

iwctl

Install and Setup Oh My Zsh

Harry Tanama — Fri, 15 Aug 2025 20:33:28 +0000

Install ZSH
Ubuntu/Debian Base:

sudo apt install zsh

Arch Linux Base:

sudo pacman -S zsh

To switch to zshell or zsh run

/usr/bin/zsh

/bin/zsh

To change your default shell to zshell or zsh

chsh -s $(which zsh)

Install Oh-my-zsh - https://github.com/ohmyzsh/ohmyzsh
Dependencies: Git, Zsh, curl, or wget
Arch Linux Base:

sudo apt install git curl

Install Oh My Zsh
Run this command in your terminal:

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

Read more instruction from ohmyzsh website: https://github.com/ohmyzsh/ohmyzsh

Install Powerlevel10k - https://github.com/romkatv/powerlevel10k
Clone the Powerlevel10k repository into your Oh My Zsh themes directory:

git clone --depth=1 https://github.com/romkatv/powerlevel10k.git "${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}/themes/powerlevel10k"

Read more information about Powerlevel10k at https://github.com/romkatv/powerlevel10k

Configure Your Theme
Edit your .zshrc file:

nano ~/.zshrc

Find the line that says ZSH_THEME="robbyrussell" and change it to:

ZSH_THEME="powerlevel10k/powerlevel10k"

Install Recommended Fonts from Nerd Fonts
https://www.nerdfonts.com/font-downloads

Powerlevel10k works best with Nerd Fonts. Install one of these MesloLGS fonts from the nerd font website above:

# Download and install MesloLGS NF fonts to this folder
mkdir -p ~/.local/share/fonts

And run the command below to apply the fonts

fc-cache -f -v

Set Terminal Font in Linux
Configure your terminal to use the installed Nerd Font:
Preferences → Profiles → Font → "MesloLGS NF"

Restart Your Shell:

source ~/.zshrc

Configure Powerlevel10k
The configuration wizard should start automatically. If not, run:

p10k configure

Optional: Popular Oh My Zsh Plugins
While configuring, you might want to add some useful plugins. Edit ~/.zshrc and find the plugins line:

plugins=(
    git
    zsh-autosuggestions
    zsh-syntax-highlighting
    web-search
    copyfile
    copybuffer
    dirhistory
    autojump
    fzf
)

More plugin can be found here https://github.com/ohmyzsh/ohmyzsh/wiki/plugins

# zsh-autosuggestions
git clone https://github.com/zsh-users/zsh-autosuggestions ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions

# zsh-syntax-highlighting
git clone https://github.com/zsh-users/zsh-syntax-highlighting.git ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting

Apply Changes restart the shell:

source ~/.zshrcc

Your terminal should now display the beautiful Powerlevel10k theme! If you ever want to reconfigure it, just run p10k configure again.

p10k configure

Install OBS in Arch Linux Setting Audio

Harry Tanama — Fri, 15 Aug 2025 20:11:08 +0000

sudo pacman -Syu

# Install OBS Studio and VLC
sudo pacman -S obs-studio vlc

sudo pacman -S vlc-plugin-ffmpeg

LSP Server and Clangd Face Challenges Dealing With Very Large Codebases

Harry Tanama — Tue, 12 Aug 2025 02:52:37 +0000

When you want to jump to function definition in Linux, you need to use Ctags or Cscope. Or you can use LSP server and clangd to jump to function definition in Linux when you are programming with C or C++.

Apparently LSP server and clangd face challenges and its limitation when it comes to managing source code navigation to jump into function definition because of large codebase, LSP server and clangd cannot read millions of lines of code inside the compile_commands.json file itself.

In large projects with millions of lines of code, the compile_commands.json file itself can become huge. clangd has to parse this and then index the entire codebase in the background. This can be memory-intensive and time-consuming.

LSP servers like clangd can struggle with "jump to definition" due to a number of factors, with the primary one being the difficulty in correctly and efficiently indexing a massive codebase, even with the help of BEAR (Bear is a tool that generates a compilation database for clang tooling). When clangd fails, my best approach is to use a more simpler tool like Ctags or Cscope.

ctags generates a tags file that allows you to quickly jump to definitions. It's a simple, low-overhead solution that works on almost any codebase. I love using ctags (Universal Ctags).

cscope is more powerful than ctags, it can perform cross-reference searches (e.g., finding all functions that call a specific function). It's an excellent choice for navigating complex codebases where understanding dependencies is key.

I can combine both ctags and cscope for source code navigation system in a large codebase project for example I am using them when compiling Godot Game Engine from the source code and enable debugging code when compiling Godot with Scons.

I am able to use cscope and ctags to navigate Godot's source code using these to navigate with jump to definition or jump to declaration.

How to Modify the Location of the Virtual Machine Image

Harry Tanama — Sun, 10 Aug 2025 15:27:22 +0000

Use the command virsh edit <image_name>
Do not include the extension .qcow2
example:

virsh edit debian13

Edit the location of the source file of your VirtIO Disk1:

After you make the changes using nano and now you can exit by pressing ctrl + x and Y to Save modified buffer?

And leave the file name /temp/virshPC0BB3.xml do not edit this file name, the virsh command or application will take care the modification of your virtual disk location at the backend

Just hit enter to accept the changes.

After that you need to cp the actual file to the new directory and you need to be a superuser to perform this action:

root@pop-os:/var/lib/libvirt/images# cp debian13.qcow2 /path/location/of_your_choosing

The name of the virtual disk location must match to the location of the actual file:

INSTALL QEMU KVM On Linux (i.e. Debian/Ubuntu Like Distro)

Harry Tanama — Sun, 10 Aug 2025 04:40:22 +0000

The command zgrep CONFIG_KVM /boot/config-$(uname -r) searches for the string CONFIG_KVM within the compressed kernel configuration file for the currently running kernel.

We will check to see if we can run virtualization or virtual machine on our Linux computer.

These information below should be displayed as
CONFIG_KVM=m or CONFIG_KVM=y
CONFIG_KVM_INTEL=m or CONFIG_KVM_INTEL=y
CONFIG_KVM_AMD=m or CONFIG_KVM_AMD=y

We are using Debian Linux Distro and you can install the following packages below

sudo apt install qemu-kvm libvirt-daemon-system libvirt-clients bridge-utils virt-manager

QEMU
Enable the libvirtd daemon on your Linux machine by running this command below:

sudo systemctl enable libvirtd.service

The above command ensures the specified service starts automatically at boot. If you don't want to have the service run at boot, you can disable the service by changing the enable to disable

Or you can run the command below to run the libvirtd service whenever you need it:

Now you can start the libvirtd daemon by running this command:

sudo systemctl start libvirtd

If you do not see any output that means, the command is successful
But if you want to double check you can run this command below:

sudo systemctl status libvirtd.service

We are using tuned in Linux to optimize performance for virtual machine. We need tuned for virtual-guest to optimizes performance for a system running as a virtual machine. virtual-host to optimizes a system to run virtual machines (as a hypervisor).

You can manage the tuned service using the tuned-adm command-line utility.

tuned-adm list: Shows all available tuning profiles on your system.

tuned-adm active: Displays the currently active profile.

tuned-adm profile <profile-name>: Switches the system to a specified profile.

tuned-adm recommend: Recommends a profile based on your system's hardware and current workload.

By using Tuned, administrators can easily and dynamically adjust system behavior without manually changing dozens of individual settings, which can be complex and error-prone.

Make sure you have installed tuned

sudo apt install tuned

Now run or start the tuned with this command:

sudo systemctl start tuned

Check your active profile using this command:

tuned-adm active

The balance profile is good for running virtual machine.
You ran this command below to check what other option in tuned-adm

tuned-adm list

We are going to select virtual-host to optimize for running inside a virtual guest.

sudo tuned-adm profile virtual-host

You can check your current profile by running this command

tuned-adm active

When you're done restart your PC to have this take effect.

After you have restart your computer, we can now configure your network bridge.

By default all virtual machine is connected to the NAT network

Type this command below to find out if the virtual machine is running on NAT network.

sudo virsh net-list --all

Type these command below to enables the automatic startup of the virtual network named default whenever the libvirt daemon starts.

sudo virsh net-start default
sudo virsh net-autostart default

Now the QEMU and KVM should be working. You can run the Virtual Machine Manager, type the command below:

virt-manager

This is link to the video how to use Virtual Machine Manager (virt-manager)
How to use Virtual Machine Manager (virt-manager)

PopOS - How to Update NVIDIA Driver

Harry Tanama — Tue, 05 Aug 2025 22:44:06 +0000

Pop!_OS handles NVIDIA driver updates automatically through its system update process. You should not manually install or click "install" on an NVIDIA driver from the Pop!_Shop if it's already installed. Doing so could potentially cause issues with your system.

Why You Shouldn't Manually Install

The different NVIDIA driver packages you see in the Pop!_Shop are not meant to be installed on top of one another. They are different versions of the driver, and Pop!_OS is designed to select the correct, most stable version for you.

When a new, stable NVIDIA driver is available, it will appear as a system update and will be installed along with other software and kernel updates. The best way to update your drivers is simply to keep your system up-to-date.

To ensure your system is fully updated, you can use the Pop!_Shop or run the following commands in the terminal:

sudo apt update
sudo apt full-upgrade

This will safely update all your packages, including the NVIDIA driver, without risking system instability. Manually trying to install a different version from the Pop!_Shop can lead to dependency conflicts and other issues that can prevent your system from booting correctly.

How to Setup Bluetooth in Arch Linux

Harry Tanama — Sun, 03 Aug 2025 22:32:45 +0000

To install and enable Bluetooth on Arch Linux install the following packages

sudo pacman -S bluez 
sudo pacman -S bluez-utils
sudo pacman -S blueman

If your blueman-manager is not working, Enable and start the Bluetooth service

Start the Bluetooth service:

sudo systemctl start bluetooth.service

If you still cannot connect to the Bluetooth earpiece

Try installing pulseaudio-bluetooth package:

sudo pacman -S pulseaudio-bluetooth

restart PulseAudio with this command:

pulseaudio -k

You can see if the Bluetooth earpiece is connected on the pulseaudio. This package pulseaudio-bluetoothBluetooth support for PulseAudio

For PulseAudio: Ensure that the pulseaudio-bluetooth package is installed. This module is responsible for automatically switching audio output to a connected Bluetooth device. If it's installed but not working, check the /etc/pulse/default.pa file and ensure the following lines are not commented out:

load-module module-switch-on-connect

If it is commented out, you can uncomment the line or type this on the /etc/pulse/default.pa file and then restart the pulseaudio

Restart pulseaudio

pulseaudio -k

And you can also restart the Bluetooth service:

Stop the Bluetooth service:

sudo systemctl stop bluetooth.service

Remove the Bluetooth cache directory:
This directory stores all pairing information, including the link keys that are causing the problem.

sudo rm -r /var/lib/bluetooth

Start the Bluetooth service again:

sudo systemctl start bluetooth.service

This will create a new, empty Bluetooth cache.

Virtualbox Installation for Arch Linux

Harry Tanama — Sun, 03 Aug 2025 14:37:16 +0000

VirtualBox - Arch Linux Wiki Page
https://wiki.archlinux.org/title/VirtualBox

Install the virtualbox package. You will also need to choose a package to provide host modules:

Check your current kernel

$ uname -r
6.15.8-arch1-2

If your kernel is Arch, choose virtualbox-host-modules-arch.

If your kernel is linux-lts kernel, choose virtualbox-host-modules-lts

If your kernel is other kernel, choose virtualbox-host-dkms

For the standard Arch kernel (linux):

sudo pacman -S virtualbox virtualbox-host-modules-arch

Load the VirtualBox Kernel Modules after install.

After the packages are reinstalled, you need to load the kernel modules. The simplest way to ensure they are all loaded is to reboot your system.

sudo reboot

If needed to Load the VirtualBox kernel modules
virtualbox-host-modules-arch and virtualbox-host-dkms use systemd-modules-load.service to load VirtualBox modules automatically at boot time.

To load the module manually, run in root mode:

sudo modprobe vboxdrv

modprobe vboxdrv is the command to load the module. It's quiet when it works.

Type this command lsmod to check if module is loaded.

lsmod | grep vboxdrv

Success: If the module is loaded, you will see output like this:

vboxdrv               516096  3 vboxnetflt,vboxnetadp

How to Compile from Source Code in Linux

Harry Tanama — Sun, 03 Aug 2025 04:15:01 +0000

The standard process for compiling and installing an application from source usually follows these steps:

Download and Extract: Download the source code, which is usually a compressed archive (.tar.gz, .tar.bz2, etc.).

Configure: Run the ./configure script (if it exists) to check for dependencies and prepare the Makefile.

./configure

Compile: Run the make command to compile the code.

make

Install: Run sudo make install to install the final binary and its associated files to the system.

sudo make install

Important Note: Always check the README or INSTALL files that come with the source code, as the build process can vary significantly between projects.

For local installation

./configure --prefix=$HOME/.local

make

make install

Cmake

Build software application using CMake:

mkdir build
cd build

Configure with a CMAKE_INSTALL_PREFIX: You specify the installation directory when running cmake.

cmake .. -DCMAKE_INSTALL_PREFIX=$HOME/.local

The .. tells cmake to look for the CMakeLists.txt file in the parent directory.

Compile and Install:

make

make install

Making the Binaries Accessible

After a local installation, the executable files are in a directory like ~/.local/bin, but your shell might not know where to find them. To fix this, you need to add this directory to your PATH environment variable.

You can do this by adding the following line to your shell's configuration file (e.g., ~/.bashrc or ~/.zshrc):

export PATH=$HOME/.local/bin:$PATH