Update linux roadmap content

Author: kamranahmedse

src/data/roadmaps/linux/content/[email protected]

@@ -1,20 +1,3 @@
 # Adding Disks
 
-Adding disks in Linux involves partitioning, creating filesystems, and mounting. Use `lsblk` to list devices, `fdisk /dev/sdX` to create partitions, `mkfs.ext4 /dev/sdX1` to create filesystems, and `mount /dev/sdX1 /mount/point` to mount. This process prepares new storage devices for seamless integration into the Linux filesystem hierarchy.
-
-The following are common commands to manage disks:
-
-- Use `lsblk` to list all block devices (disk and partitions).
-- Use `fdisk /dev/sdX` to create a new partition on a disk.
-- Use `mkfs.ext4 /dev/sdX1` to create a new filesystem on a partition.
-- Use `mount /dev/sdX1 /mount/point` to mount a filesystem to a directory.
-
-```shell
-# example commands to add new disk
-lsblk                     # list all disks and partitions
-sudo fdisk /dev/sdb       # let's suppose new disk is /dev/sdb
-sudo mkfs.ext4 /dev/sdb1  # make filesystem(e.g., ext4) on partition 1
-sudo mount /dev/sdb1 /mnt # mount new filesystem to /mnt directory
-``` 
-
-Remember to replace `/dev/sdb` and `/dev/sdb1` with your actual disk and partition identifiers. The mount point `/mnt` may also be replaced with any other directory as per your system's structure and preference.
+Adding disks in Linux involves partitioning, creating filesystems, and mounting. Use `lsblk` to list devices, `fdisk /dev/sdX` to create partitions, `mkfs.ext4 /dev/sdX1` to create filesystems, and `mount /dev/sdX1 /mount/point` to mount. This process prepares new storage devices for seamless integration into the Linux filesystem hierarchy.

src/data/roadmaps/linux/content/[email protected]

@@ -2,13 +2,3 @@
 
 Evaluating available memory is crucial for Linux system health monitoring. Use command-line tools like `free`, `vmstat`, and `top` to track memory usage and performance metrics. The `free -h` command shows total, used, free, shared, buffer/cache, and available memory in human-readable format. Essential for maintaining optimal server performance and troubleshooting resource issues.
 
-The `free` command, for instance, gives a summary of the overall memory usage including total used and free memory, swap memory and buffer/cache memory. Here's an example:
-
-```bash
-$ free -h
-              total        used        free      shared  buff/cache   available
-Mem:           15Gi       10Gi       256Mi       690Mi       5.3Gi       4.2Gi
-Swap:         8.0Gi       1.3Gi       6.7Gi
-```
-
-In this output, the '-h' option is used to present the results in a human-readable format. Understanding the state of memory usage in your Linux server can help maintain optimal server performance and troubleshoot any potential issues.

src/data/roadmaps/linux/content/boot-loaders@o5lSQFW-V_PqndGqo1mp3.md

@@ -2,13 +2,6 @@
 
 Boot loaders load the OS kernel into memory when systems start. Common Linux boot loaders include GRUB (modern, feature-rich with graphical interface) and LILO (older, broader hardware support). Boot loaders initialize hardware, load drivers, start schedulers, and execute init processes. Use `sudo update-grub` to update GRUB configuration. Enable multi-OS booting on single machines.
 
-```bash
-# This command updates the GRUB bootloader 
-sudo update-grub
-```
-
-Irrespective of the type of Boot Loader used, understanding and configuring them properly is essential for maintaining an efficient, stable and secure operating system. Boot loaders also allow users to switch between different operating systems on the same machine, if required.
-
 Visit the following resources to learn more:
 - [@article@comprehensive documentation of Bootloader - archlinux wiki](https://wiki.archlinux.org/title/Arch_boot_process#Boot_loader)
 - [@article@What Is GRUB Bootloader in Linux?](https://phoenixnap.com/kb/what-is-grub)

src/data/roadmaps/linux/content/[email protected]

@@ -1,14 +1,3 @@
 # Booting Linux
 
-Linux booting involves several stages: POST, MBR, GRUB, Kernel, Init, and GUI/CLI. The bootloader loads the kernel into memory, which detects hardware, loads drivers, mounts filesystems, starts system processes, and presents login prompts. GRUB configuration is managed through `/etc/default/grub` with settings like timeout and default boot options.
-
-Here is an example of the GRUB configuration file `/etc/default/grub` which is used to configure the GRUB bootloader options:
-
-```bash
-GRUB_DEFAULT=0
-GRUB_TIMEOUT=5
-GRUB_DISTRIBUTOR=`lsb_release -i -s 2> /dev/null || echo Debian`
-GRUB_CMDLINE_LINUX_DEFAULT="quiet splash"
-GRUB_CMDLINE_LINUX=""
-```
-This is a basic introduction to booting Linux. However, the specifics may vary depending on the Linux distribution and the specific configurations of your system.
+Linux booting involves several stages: POST, MBR, GRUB, Kernel, Init, and GUI/CLI. The bootloader loads the kernel into memory, which detects hardware, loads drivers, mounts filesystems, starts system processes, and presents login prompts. GRUB configuration is managed through `/etc/default/grub` with settings like timeout and default boot options.

src/data/roadmaps/linux/content/[email protected]

@@ -2,20 +2,3 @@
 
 Linux system logs provide chronological records of events for debugging and troubleshooting, stored in `/var/log` directory. Use `dmesg` for kernel messages and `journalctl` for systemd logs. `journalctl -u service_name` shows logs for specific services. Essential skill for system administration, monitoring, and effective troubleshooting in Linux environments.
 
-Checking Logs Under Service Management in Linux plays a vital role in systems administration and troubleshooting procedures. Logs are fundamental for an in-depth understanding of what's going on inside a Linux system. These records provide a chronological record of events related to your system for use in debugging and troubleshooting problems.
-
-Several essential logs generated by system processes, users and administrator actions can be found in `/var/log` directory. Logs can be accessed and viewed using several commands. For example, the `dmesg` command can be used to display the kernel ring buffer. Most system logs are managed by `systemd` and can be checked using the command `journalctl`.
-
-```shell
-journalctl
-```
-
-This command will show the entire system log from the boot to the moment you're calling the journal. 
-
-To display logs for a specific service, the `-u` option can be used followed by the service's name.
-
-```shell
-journalctl -u service_name
-```
-
-Remember, understanding and monitoring your system logs will provide you a clear view of what's going on in your Linux environment. It is a vital skill worth developing to effectively manage and troubleshoot systems.

src/data/roadmaps/linux/content/[email protected]

@@ -1,30 +1,6 @@
 # Command Help
 
-Command help in Linux is an essential feature that enables users to navigate through Linux shell commands with ease. This feature displays brief information on how to use these commands. For instance, typing 'man' before any command brings up the manual entry for that command which explains what the command does, its syntax and the available options. Another popular command is 'help' which is more suited for shell built-in functions, giving a brief description about each. These command line services are extremely beneficial for beginners trying to learn how to use the Linux shell, as well as seasoned users who may need to look up the specifics of seldom used commands. You can also get a TLDR of a command with example usage by using the TLDR package.
-
-To view the manual entry for any command, use:
-
-```bash
-man [command]
-```
-
-For built-in shell functions, use:
-
-```bash
-help [command]
-```
-
-Moreover, you can add the *--help* flag to almost any command to get more information about it.
-For example:
-```bash
-date --help
-```
-
-To view examples with TLDR, use:
-
-```bash
-tldr [command]
-```
+Linux command help provides documentation and usage information for shell commands. Use `man command` for detailed manuals, `help command` for shell built-ins, `command --help` for quick options, and `tldr command` for practical examples. Essential for learning command syntax, parameters, and functionality in Linux terminal environments.
 
 Learn more from the following resources:
 

src/data/roadmaps/linux/content/[email protected]

@@ -1,23 +1,3 @@
 # Conditionals
 
-Shell conditionals allow scripts to make decisions based on conditions using `if`, `elif`, and `else` statements. These control process flow by evaluating string variables, arithmetic tests, or process status. Conditions are checked sequentially - if true, the corresponding code block executes; otherwise, it moves to the next condition until finding a match or reaching `else`.
-
-Here's a simple illustration of how they work:
-
-```bash
-#!/bin/sh
-a=10
-b=20
-
-if [ $a -lt 20 ]
-then
-   echo "a is less than b"
-elif [ $a -gt 20 ]
-then
-   echo "a is greater than b"
-else
-   echo "a is equal to b"
-fi
-```
-
-In the above script, the condition inside the `if` statement is being checked. If the condition is `true`, then the code block inside the `if` statement gets executed, otherwise, it moves to the `elif` condition and so on. If none of those conditions is satisfied, then the code block inside the `else` statement will be executed.
+Shell conditionals allow scripts to make decisions based on conditions using `if`, `elif`, and `else` statements. These control process flow by evaluating string variables, arithmetic tests, or process status. Conditions are checked sequentially - if true, the corresponding code block executes; otherwise, it moves to the next condition until finding a match or reaching `else`.

src/data/roadmaps/linux/content/creating--deleting-files--dirs@9oo2fxTM2_p0VYPBroqxa.md

@@ -1,39 +1,6 @@
-# Creating Files
+# Creating and Deleting Files
 
-Creating files in Linux is about making new blank or filled files on your computer. You can use commands like `touch` to create an empty file, `echo` to make a file with some text inside, or `cat` to type directly into a new file. These commands help you set up and save your documents or data.
-
-Here's an example of file creation with the `touch` command:
-
-```bash
-touch newfile.txt
-```
-
-and with `cat` command:
-
-```bash
-cat > newfile.txt
-```
-
-Both these commands create a new "newfile.txt" if it does not already exist.
-
-# Deleting Files
-
-Deleting files in Linux means getting rid of unwanted or unnecessary files from your computer. You use the `rm` command to delete a file, and it's permanent, so be careful. You can also use `rm -i` (interactive) to ask for confirmation before deleting, which helps prevent accidental loss of important files.
-
-```bash
-# Deletes the file named example.txt
-rm example.txt
-```
-
-```bash
-# Ask for confirmation
-rm -i [filename]
-```
-
-```bash
-# Removes an empty directory
-rmdir [directory] 
-```
+Linux file operations include creating files with `touch` (empty files) or `cat > filename` (with content) and deleting with `rm filename`. Use `rm -i` for confirmation prompts and `rmdir` for empty directories. File deletion is permanent - no recycle bin. Essential commands for basic file management and system administration.
 
 Learn more from the following resources:
 

src/data/roadmaps/linux/content/creating-files@9oo2fxTM2_p0VYPBroqxa.md

@@ -1,39 +1,6 @@
 # Creating Files
 
-Creating files in Linux is about making new blank or filled files on your computer. You can use commands like `touch` to create an empty file, `echo` to make a file with some text inside, or `cat` to type directly into a new file. These commands help you set up and save your documents or data.
-
-Here's an example of file creation with the `touch` command:
-
-```bash
-touch newfile.txt
-```
-
-and with `cat` command:
-
-```bash
-cat > newfile.txt
-```
-
-Both these commands create a new "newfile.txt" if it does not already exist.
-
-# Deleting Files
-
-Deleting files in Linux means getting rid of unwanted or unnecessary files from your computer. You use the `rm` command to delete a file, and it’s permanent, so be careful. You can also use `rm -i` (interactive) to ask for confirmation before deleting, which helps prevent accidental loss of important files.
-
-```bash
-# Deletes the file named example.txt
-rm example.txt
-```
-
-```bash
-# Ask for confirmation
-rm -i [filename]
-```
-
-```bash
-# Removes an empty directory
-rmdir [directory] 
-```
+Linux file creation uses `touch` for empty files, `echo "text" > filename` for text files, or `cat > filename` for interactive input. Commands like `mkdir` create directories. File creation is immediate and permanent. Essential for organizing data, scripts, and configuration files in Linux systems.
 
 Learn more from the following resources:
 

src/data/roadmaps/linux/content/[email protected]

@@ -2,28 +2,3 @@
 
 Creating Linux services involves setting up background applications using systemd service files. Services run continuously performing essential tasks like web servers, databases, and mail servers. Create `.service` files in `/etc/systemd/system/` with Unit, Service, and Install sections. Control services using `systemctl` commands. Best practice: avoid running services as root for security.
 
-In Linux, service management refers to starting, stopping, enabling, and managing software services. Understanding how to control services is crucial for controlling a Linux server or desktop. 
-
-Typically, a service is an application that runs in the background waiting to be used, or carrying out essential tasks. Common kinds of services include web servers, database servers, and mail servers. 
-
-Creating services in Linux would thus refer to the process of setting up these background applications to run and perform the desired tasks. This process often includes writing service files (script) that specify how to start, stop, and restart the service using a service management system. 
-
-The most common service management system in modern Linux distributions is systemd. With systemd, services are defined by placing service unit files in specific directories. 
-
-For instance, we could create a simple `my_service.service` file:
-
-```
-[Unit]
-Description=My Custom Service
-After=network.target
-
-[Service]
-ExecStart=/path/to/your/executable
-
-[Install]
-WantedBy=multi-user.target
-```
-
-This service file can be placed under `/etc/systemd/system/` to make systemd recognize it. You would then control the service using `systemctl`, systemd's command tool. 
-
-Note that best practices in Linux dictate that we should not run services as root whenever possible, for security reasons. Instead, we should create a new user to run the service.