Linux Tips For Normal Users

A full installation means Linux is the only operating system on your computer. The entire hard drive is dedicated to Linux.

✅ Advantages:

• Maximum Performance: Linux has full access to all hardware resources without sharing with another OS
• Simpler Setup: No complex partition management or bootloader configuration
• No Disk Space Wasted: All disk space is available for Linux files and applications
• Better for Learning: Forces you to fully commit and learn the system
• No Boot Conflicts: Windows updates won't break your Linux bootloader
• Ideal for Old Computers: Breathe new life into aging hardware

❌ Disadvantages:

• No Windows Access: You cannot run Windows applications natively (though Wine/VMs are alternatives)
• Irreversible Commitment: Requires backing up and wiping all existing data
• Learning Curve: Must adapt to Linux for all computing tasks
• Software Compatibility: Some Windows-only software may not have Linux alternatives

Dual booting means installing Linux alongside Windows on the same computer. When you start your computer, you choose which operating system to use.

✅ Advantages:

• Best of Both Worlds: Use Windows for gaming/essential software and Linux for learning/development
• Safety Net: You always have a working Windows system to fall back on
• Gradual Transition: Learn Linux at your own pace while keeping Windows familiar
• Hardware Compatibility: Can test Linux hardware support while keeping Windows as backup
• File Sharing: Access the same files from both operating systems (with proper partition setup)

❌ Disadvantages:

• Disk Space Sharing: Must divide your hard drive between both systems
• Bootloader Complexity: Windows updates can sometimes overwrite the Linux bootloader
• Time Zone Issues: Windows and Linux handle hardware clock differently (can be fixed)
• Reboot Required: Cannot run both operating systems simultaneously
• Partition Risks: Resizing Windows partitions carries a small risk of data loss

For complete beginners, virtual machines offer the safest way to try Linux.

How It Works:

Software like VirtualBox or VMware creates a "virtual computer" inside Windows. Linux runs in a window, sharing resources with your main OS.

✅ Advantages:

• 100% Safe: Cannot damage your Windows installation
• No Partitioning: Linux lives in a file, not on disk partitions
• Simultaneous Use: Run Linux and Windows side by side
• Snapshots: Save system state and roll back if something breaks
• Easy Removal: Just delete the virtual machine files

❌ Disadvantages:

• Performance Overhead: Linux runs slower than on real hardware
• Limited Hardware Access: Graphics acceleration, USB devices may have limitations
• Not Suitable for Production: Not ideal for long-term daily use

Secure Boot is a UEFI feature that prevents unauthorized operating systems and malware from loading during startup. It checks that every piece of boot software is digitally signed by trusted keys.

How Secure Boot Affects Linux:

• Ubuntu and Fedora: Fully support Secure Boot (their bootloaders are signed by Microsoft)
• Some Distributions: May not have signed bootloaders (Debian, Arch, many others)
• Dual Boot Impact: Can prevent Linux from booting if not properly configured
• NVIDIA Drivers: Proprietary drivers may not load with Secure Boot enabled

Your Options:

Method 1: Using Boot Key During Startup

Immediately after turning on your computer, press the appropriate key repeatedly:

Method 2: From Windows 10/11

1. Open Settings → Update & Security → Recovery
2. Under "Advanced startup," click Restart now
3. Choose Troubleshoot → Advanced options → UEFI Firmware Settings
4. Click Restart

Important Settings to Check Before Linux Installation:

• Boot Mode: Should be set to match your installation media (UEFI or Legacy)
• Secure Boot: Enable/disable based on your distribution choice
• Fast Boot: Disable this – can prevent USB booting
• SATA Mode: Should be AHCI, not RAID or Intel RST (common issue!)
• Boot Order: Ensure USB/DVD is prioritized over hard drive

CSM (Compatibility Support Module)

Enables UEFI to boot legacy BIOS operating systems. Enable this if you're mixing old and new.

Fast Boot

Skips some hardware checks to speed up startup. Disable for Linux installation.

PXE Boot

Network booting – can be disabled to speed up boot if not needed.

TPM (Trusted Platform Module)

Security chip used by Windows 11. Linux supports it, but may require configuration.

VT-x/AMD-V

Hardware virtualization support. Enable this if you plan to use virtual machines.

• USB Drive: Minimum 4GB (8GB recommended for most distributions)
• Linux ISO File: Downloaded from official distribution website
• Bootable USB Creation Tool: Rufus (Windows), BalenaEtcher (All platforms), or dd (Linux)
• Working Computer: To create the bootable USB

For Linux users comfortable with terminal, the dd command is the most direct method.

How to Identify the Correct USB Device:

• Run lsblk before and after inserting USB – the new device is your USB
• Check size – a 8GB USB will show as 7.5GB in lsblk
• Look for device without partitions (/dev/sdb not /dev/sdb1)

Problem: USB Doesn't Boot

• Secure Boot enabled? Try disabling or using a signed distribution
• Wrong boot mode? Ensure USB was created for correct mode (UEFI vs Legacy)
• Fast Boot enabled? Disable in BIOS
• USB 3.0 issues? Try a USB 2.0 port
• Corrupted ISO? Verify ISO checksum (see below)

Problem: "Failed to load COM32" or Similar Errors

• Usually caused by using wrong partition scheme – recreate USB with correct scheme
• Try a different USB creation tool

Problem: USB Works on Some Computers but Not Others

• Different computers have different BIOS/UEFI implementations
• Create USB with "compatibility" mode if available

Before creating your bootable USB, you should verify the ISO integrity to ensure it downloaded correctly and hasn't been tampered with.

What is a Checksum?

A checksum is like a digital fingerprint of a file. The official website provides MD5, SHA-1, or SHA-256 hashes. After downloading, you generate the same hash and compare.

How to Verify:

Compare the output with the hash on the official download page. They must match exactly.

Imagine your hard drive is a large empty warehouse:

• Unpartitioned Drive: One huge open space – chaotic and hard to organize
• Partitions: Building walls to create separate rooms – office, storage, workshop
• Filesystems: How each room is organized – shelving, filing cabinets, workbenches
• Mount Points: Doors with signs – "/" for the main room, "/home" for personal stuff

In Linux, everything is a file, and partitions are attached (mounted) to directories. The root partition (/) is like your main living area – essential for the system to function.

Scenario 1: Simple Single Partition (Beginners, 120GB SSD)

/dev/sda1: / (root) - 120GB, ext4
(swap file instead of partition – modern approach)

Pros: Simplest, no space wasted. Cons: Reinstalling loses all data.

Scenario 2: Root + Home Separation (Recommended, 500GB HDD)

/dev/sda1: / (root) - 50GB, ext4
/dev/sda2: /home - 430GB, ext4
/dev/sda3: swap - 8GB (if RAM = 8GB)

Pros: Safe reinstalls, organized. Cons: Slightly more complex.

Scenario 3: Dual Boot with Windows (250GB SSD)

/dev/sda1: Windows C: - 100GB, NTFS
/dev/sda2: / (root) - 50GB, ext4
/dev/sda3: /home - 80GB, ext4
/dev/sda4: Shared Data - 20GB, NTFS (for files both OS need)

Scenario 4: Advanced Multi-Partition (Server/Enthusiast)

/dev/sda1: /boot - 1GB, ext2
/dev/sda2: / (root) - 30GB, ext4
/dev/sda3: /home - 200GB, ext4
/dev/sda4: /var - 20GB, ext4 (separate logs)
/dev/sda5: /tmp - 5GB, ext4 (separate temp files)
/dev/sda6: swap - 8GB

Here's what you'll actually see during installation:

Option 1: "Erase disk and install Ubuntu" (Automatic)

• Simplest option – wipes entire disk, creates single partition
• Good for: Full installation, beginners, virtual machines
• Warning: All existing data on the disk will be lost!

Option 2: "Install Ubuntu alongside Windows" (Automatic Dual Boot)

• Installer automatically shrinks Windows partition and creates space for Linux
• Good for: Simple dual boot without manual partitioning
• Limitation: Less control over partition sizes

Option 3: "Something else" (Manual Partitioning)

Choose this for full control. Here's what to do:

1. Select free space and click + to add partition
2. Create root partition:
   • Size: 20000-30000 MB (20-30GB)
   • Type: Primary
   • Location: Beginning
   • Use as: Ext4 journaling file system
   • Mount point: /
3. Create home partition (optional):
   • Size: Remaining space (or desired size)
   • Use as: Ext4
   • Mount point: /home
4. Create swap area (optional):
   • Size: Equal to RAM (for hibernation) or 4-8GB
   • Use as: swap area
5. For UEFI systems: Ensure an EFI System Partition exists (usually created by Windows)
6. Click Install Now and confirm changes

The "traditional" rule (swap = 2× RAM) is outdated. Modern systems with plenty of RAM rarely use swap.

If you didn't create swap during installation, you can easily add a swap file:

To Disable and Remove Swap File:

Hibernation saves the contents of RAM to swap and powers off completely. When you turn on your computer, everything is restored exactly as you left it.

Requirements for Hibernation:

• Swap size must be at least equal to RAM (slightly larger recommended)
• Swap must be a partition (swap file hibernation is possible but more complex)
• Kernel parameter: resume=UUID=swap-partition-uuid must be added
• Initramfs: Must include the resume hook

Check if Hibernation is Available:

Every Linux distribution is built around a package format. A package is an archive containing executable files, configuration files, documentation, and metadata (name, version, dependencies, conflicts). The most common are .deb (Debian/Ubuntu) and .rpm (Red Hat/Fedora). The metadata declares which shared libraries (libc.so.6, libgtk-3.so.0) are required. The package manager reads these declarations and installs missing dependencies automatically from repositories.

Why shared libraries? Instead of each application bundling its own copy of, say, a JPEG loader, they all use the system’s libjpeg. This reduces disk usage and allows one security update to fix dozens of apps. However, it creates the famous dependency hell when two applications need different versions of the same library — that’s where modern package managers and sandboxed formats (Flatpak, Snap) shine.

📊 Example: GIMP dependencies (simplified)

gimp (2.10.30-1) depends on:
 ├─ libc6 (>= 2.33)          [core C library]
 ├─ libgegl-0.4-0 (>= 0.4.32) [image processing]
 ├─ libgdk-pixbuf-2.0-0       [GTK image loading]
 ├─ libgtk-3-0 (>= 3.24)      [GUI toolkit]
 └─ … 40+ more
                                     

apt install gimp fetches every missing piece. The same applies to rpm-based distros with dnf. This is why you never download a single .deb from a random site and double‑click — if it was built for a different release, dependencies may not match, leading to broken system state.

Most users install pre‑compiled binary packages. Some distributions (Gentoo, Source‑based) compile everything from source code on your machine. Even on Ubuntu, you can compile from source using ./configure && make && sudo make install, but it’s not recommended because the package manager loses track of those files — later updates or removals become messy. Always prefer binary packages.

Modern Linux desktops include friendly app stores: they display applications with screenshots, user reviews, and one‑click install. Under the hood, they are front‑ends to the same package managers (apt, dnf, etc.) plus Flatpak and Snap. For example, GNOME Software uses PackageKit, which abstracts distro differences. These tools are perfect for casual users: they handle authentication, show progress, and integrate with system updates.

But they hide complexity: you cannot easily see exactly which packages will be installed, pin versions, or fix broken dependencies from the GUI. If the GUI crashes during an operation, you might need the terminal to recover.

The command line provides surgical control. With apt you can:

• apt search <term> – search packages
• apt show <pkg> – detailed metadata
• apt list --installed – see everything
• apt upgrade --dry-run – preview changes
• apt-mark hold <pkg> – prevent updates

Advanced tasks like pinning (priority control) or downloading source packages are only possible via CLI. Moreover, in server environments there is no GUI at all.

Real mastery means being comfortable with both — the GUI for discovery, the CLI for reliability.

1. Distribution repositories (main/restricted/universe/multiverse): millions of packages, tested for the release. Use apt install directly. Example: sudo apt install vlc.

2. PPAs (Personal Package Archives): for newer versions (e.g., ppa:libreoffice/ppa). Add with sudo add-apt-repository ppa:libreoffice/ppa && sudo apt update. Only use trusted PPAs (check launchpad.net reputation).

3. Official .deb packages from developers (Chrome, Zoom, VS Code). Download and install with sudo apt install ./google-chrome.deb. This respects dependencies. Do not use dpkg -i alone because it won’t fetch missing dependencies — always apt install on the .deb file.

4. Manual compilation / random binaries — highest risk, only if no other option.

• sudo apt remove vlc – deletes binaries, keeps config files (/etc/vlc).
• sudo apt purge vlc – wipes config as well.
• sudo apt autoremove – cleans up libraries that were installed as dependencies and are no longer needed (run after removals).

To remove a PPA: sudo add-apt-repository --remove ppa:name or delete the .list file in /etc/apt/sources.list.d/.

• sudo apt --fix-broken install – resolves dependency conflicts.
• sudo dpkg --configure -a – if dpkg was interrupted.
• If a bad PPA breaks update, disable it by moving its .list file and run sudo apt update.

Flatpak bundles an app with its own dependencies in a sandbox, yet shares common runtimes (like Freedesktop 22.08) to save space. Apps run confined; you control permissions via flatpak override or Flatseal. Main repo: Flathub (flathub.org). Commands:

flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
flatpak install flathub org.gimp.GIMP
flatpak run org.gimp.GIMP

Flatpak apps integrate with the desktop (themes, portals) and can be updated with flatpak update. Ideal for GUI apps.

Similar container concept but with stricter mandatory updates. Snap packages are transactional and roll back automatically if an update fails. Commands: snap install gimp, snap refresh, snap remove gimp. They auto‑update every day (can be changed). Some criticize centralization and slower start. Good for CLI tools and server apps too.

No installation: download, chmod +x App, run. Ideal for portable usage or trying software without committing. No sandbox, no automatic updates. Can be integrated with tools like AppImageLauncher. Great for older distributions that lack recent packages.

/etc/apt/sources.list and files under /etc/apt/sources.list.d/ define which repositories apt uses. A typical line: deb http://archive.ubuntu.com/ubuntu jammy main restricted. The GPG key (downloaded separately) ensures packages haven't been tampered with. When you add a PPA, add-apt-repository installs both the entry and the key.

Never add a repo without verifying its key fingerprint. For third‑party repos like Docker, you follow official instructions that include the key fingerprint.

sudo add-apt-repository ppa:graphics-drivers/ppa
sudo apt update

Now you can install nvidia driver updates from that PPA. To remove: sudo add-apt-repository --remove ppa:graphics-drivers/ppa.

For apps that have no native version, consider Wine or Bottles (Flatpak) to run Windows software, but expect some friction. Virtual machines are another option.

• Before upgrading, run apt list --upgradable to see what will change.
• Use apt upgrade (never dist-upgrade unless you understand it).
• Hold back critical packages: sudo apt-mark hold linux-image-generic
• Use Timeshift to take filesystem snapshots before large updates.
• Enable automatic security updates via unattended-upgrades.

sudo apt update downloads the latest package lists from all configured repositories. It does not install anything — it simply tells your system what new versions are available. Always run this before any install or upgrade.

sudo apt upgrade installs newer versions of packages you already have, but it never removes packages. If a new version requires a dependency that must be removed, the upgrade is held back. To see held packages: apt-mark showhold.

sudo apt full-upgrade performs the same as upgrade but will remove packages if necessary to complete the upgrade. This is useful when switching between major releases (e.g., Ubuntu 22.04 → 22.10) but can be risky on a stable system — run it only when you intend to allow removals.

Standard daily driver: sudo apt update && sudo apt upgrade -y.

Always simulate: apt upgrade --dry-run shows what would happen. Logs are stored in /var/log/apt/history.log.