Managing users in RHEL is kind of like that. You decide who gets in, what they can do, and how much control they have. Without proper management, things can get messy fast—like that friend who somehow DJs when no one asks.

So, let’s dive into user management and ensure your Linux system stays organized, secure, and drama-free! 🚀

Table Of Contents

1. What is a User in Linux?

   • Understanding sudo in User Management

2. User Management Commands in Linux

   • How to Add a User

   • How to Check if a User is Created

   • How to Assign a Password

   • How to Switch Users

   • Understanding Groups in Linux

   • How to Modify Users

3. Final Words

What is a User in Linux?

A user in Linux is an account that allows someone (or a process) to interact with the system. Since Linux is a multi-user operating system, multiple users can exist on the same system, each with their own settings, files, and permissions. Users can have different levels of permissions, which determine what they can access or modify on the system.

Linux categorizes users into three main types based on their roles and privileges:

1. Privileged Users: These users have unrestricted access to the entire system. They have the highest level of permissions and can perform any operation on the system. They can install/remove software, modify system files, create/manage users, and even delete everything. These users are also called root users.

2. System Users: The system creates these users to run background processes or services. They can’t login like a normal user. Their sole purpose is to manage system operations like databases, web servers and scheduled tasks.

3. Normal Users: These are the everyday users created by administrators or during system installation. They have their home directory and can store personal files and settings. They can’t modify system files but can execute tasks within their permission scope.

Understanding sudo in User Management

The sudo (Superuser Do) command allows a regular user to execute administrative tasks with elevated privileges. Since user management tasks—such as adding, modifying, or deleting users—require root access, normal users must use sudo before these commands.

Note that the following commands are executed as the root user. If you are using a normal user account, you must prefix them with sudo to perform user management tasks.

Now let’s see how we manage users on RHEL.

User Management Commands in Linux

How to add a user

To create a new user account, use following command:

Syntax:

useradd [user_name]

Example:

useradd Tanishka # Root user
sudo useradd Tanishka # Normal user

Once you create a user, you can verify its existence in the /etc/passwd file. This file stores essential user account information (but not passwords, despite the name).

How to check if a user is created

To confirm the user entry in /etc/passwd, use one of the following methods:

1. View the file using cat or grep

cat /etc/passwd # Displays entire file content
grep Tanishka /etc/passwd # Displays information about Tanishka user only

2. Use id command:

The id command is used to display a user’s UID (User ID), GID (Group ID), and the groups they belong to. It helps in verifying user information and checking permissions.

id Tanishka
# Displays user id of Tanishka,
# hence verifying user has been created

Let’s understand what’s going on in the /etc/password fields. Each line in /etc/passwd represents a user account and contains seven fields separated by colons (:):

username:x:UID:GID:comment:home_directory:shell

How to Assign a Password

Once an account is created, it’s essential to assign a password to the account. Otherwise, that account can’t be logged in through a GUI login interface. To give a password to a user account, user this command:

Syntax:

passwd [user_name]

Example:

passwd Tanishka

You will be prompted to enter the password. Enter the password and you’re all set! Even though user information is stored in /etc/passwd file, actual information about the password is stored in the /etc/shadow file (weird, I know…).

To see the content of the /etc/shadow file, use this command:

cat /etc/shadow

Each line in /etc/shadow represents a user account password and contains nine fields separated by colons (:):

username:password:lastchg:min:max:warn:inactive:expire:reserved

To change password aging information, you use the chage (short for change age) command like this:

Syntax:

chage [OPTIONS] [user_name]

Example:

chage -l tanishka # Lists the current password aging information
chage -m 10 tanishka # Sets the minimum days to change password
chage -M 10 tanishka # Sets the maximum days password must be changed
chage -W 7 tanishka # Sets the number of days before the password expires that the user will be warned to change the password
chage -I 10 tanishka # Sets the number of days after password expiration that the account will be disabled if not logged in
chage -E 2025-12-31 tanishka # Sets the date when the user account will expire 
chage -d 2024-12-25 tanishka # Sets the last password change date

Now that you have learned to create users and assign passwords, you need to know how to switch between users. Let’s see that now.

How to Switch Users

The su (Substitute User) command allows you to switch from one user to another without logging out of the current session.

Syntax:

su - [user_name]

Example:

su - Tanishka # Switches to Tanishka user

• su stands for "substitute user" (or "switch user").

• The - (hyphen) loads the target user's full environment, including their shell, path, and profile settings (similar to logging in as that user).

• If no username is provided, it switches to the root user by default.

To return to original or root user, simply enter ‘exit’.

Understanding Groups in Linux

Just like a party where guests can belong to different social circles, Linux groups allow users to be part of different permission levels. Groups help manage file access, system privileges, and administrative controls efficiently.

Linux has two types of groups:

1. Primary Group:

• Every user has one primary group.

• When a user creates a new file, it belongs to their primary group.

• It is usually named the same as the username.

2. Secondary Groups:

• A user can belong to multiple secondary groups.

• These groups provide additional permissions beyond the primary group.

• Users can be assigned to various secondary groups to access shared resources.

To check a user’s group membership:

id [user_name]

This displays the user’s UID, primary group (GID), and any secondary groups they belong to.

To add a new group:

groupadd [group_name]

How to Modify a User

Sometimes, you might need to update user details, such as changing usernames, user IDs, group memberships, home directories, or login shells. You use the usermod command to modify existing user accounts while preserving their files and configurations.

Syntax:

usermod [OPTIONS] [user_name]

Let’s break down the different options available for modifying user accounts.

1. Change the username

If you want to rename an existing user, use the -l option:

Syntax:

usermod -l new_username old_username

Example:

usermod -l tanishkamakode tanishka

This renames tanishka to tanishkamakode. Just keep in mind that the home directory remains the same (/home/tanishka), so you might need to rename it manually.

To rename the home directory as well, use:

mv /home/tanishka /home/tanishkamakode

2. Change the user id:

Each user has a unique User ID (UID). If you need to change it, use -u.

Syntax:

usermod -u new_UID user_name

Example:

usermod -u 2001 tanishka

This changes tanishka's UID to 2001. Before you do this, you’ll want to make sure that no other user has the same UID. This is important.

If the user owns files under the old UID, you should update them after changing the UID.

3. Change the primary group

Every user belongs to a primary group. To change it, use -g.

Syntax:

usermod -g new_group user_name

Example:

usermod -g developers tanishka

This changes tanishka's primary group to developers. Just keep in mind that usermod -g developers tanishka removes the user from all secondary groups. To avoid that, just make sure you check and re-add secondary groups as needed.

Also, the group must exist beforehand. To create a group, run this command:

Syntax:

groupadd [group_name]

Example:

groupadd developers

Now, to check tanishka’s group, do the following:

id tanishka

4. Add to a secondary group

A user can belong to multiple secondary groups. Use -G to assign them.

Syntax:

usermod -G group1,group2 user_name

Example:

usermod -G linux,docker tanishka

This adds tanishka to the sudo and docker groups. Just keep in mind that this replaces any existing secondary groups that the user might already belong to. To add groups without removing the current ones, use -aG (append to groups) like this:

usermod -aG linux,docker tanishka

5. Change the home directory:

You can change a user’s default home directory using -d.

Syntax:

usermod -d /new/home_directory user_name

Example:

usermod -d /home/tani tanishka

This sets tanishka's home directory to /home/tani, but it does not move existing files. To move them, add the -m option:

usermod -d /home/tani -m tanishka

After moving the home directory, just make sure you’ve updated file ownership.

6. Change the login shell:

The default shell for a user can be changed using -s.

Syntax:

usermod -s /new/shell user_name

Example:

usermod -s /bin/zsh tanishka

This changes tanishka's default shell to zsh. Common shells include:

• /bin/bash (default)

• /bin/sh

• /bin/zsh

• /usr/sbin/nologin (to disable login)

With usermod, you can fine-tune user settings to match system requirements. Always check changes using:

id tanishka
grep tanishka /etc/passwd

Final Words

In this article, we explored the fundamentals of user management in RHEL, a crucial aspect of system administration. We started with creating and managing users, then moved on to handling groups.

If you're new to Linux and want to build a strong foundation, check out my first tutorial on Basic Linux Commands, where I cover essential commands every beginner should know. You can also read my second tutorial on Vim to learn how to navigate and edit text efficiently in this powerful editor. These articles will complement what you’ve learned about user management here.

Keep practicing these commands, and soon they’ll become second nature to you. Mastery comes with repetition, so continue experimenting and applying these fundamentals in real-world scenarios.

Stay tuned for more articles. Get ready to take your RHEL skills to the next level.

Let’s connect!

For devs, text editors are the ultimate multitools, shaping how we create, manage, and transform raw data into meaningful output.

While modern editors like VS Code and Sublime Text have gained popularity for their sleek interfaces, there’s something timeless about the simplicity and power of classic tools.

Loved by some and feared by others, Vim is a text editor that has stood the test of time. Born from its predecessor Vi, Vim (Vi Improved) offers unparalleled speed, versatility, and control.

In this tutorial, you’ll learn what makes Vim so special. We’ll explore its commands, text filtering, and string manipulation capabilities to help you harness its true power.

What we’ll cover:

1. Text Editors in Linux

2. How to Open the Vim Editor

3. Modes in Vim

4. Basic Vim Commands

5. Cut, Copy, Paste, and Delete Commands

6. Search and Replace Commands

7. How to Read Files using more and less

8. Text Filters

9. Text Summarization Tool: wc

Text Editors in Linux

Linux provides a variety of text editors, each designed for different types of users – from beginners to advanced developers.

Editors like Nano are great for newcomers who need a simple, user-friendly experience in the terminal. Nano displays helpful commands at the bottom of the screen, making it easy to navigate without a steep learning curve.

Gedit, the default editor for the GNOME desktop environment, offers a clean, graphical interface ideal for basic text editing. On the other hand, Kate caters to KDE desktop users and provides a more feature-rich experience, with multiple windows, syntax highlighting, and an integrated terminal.

Emacs is a versatile and highly customizable editor that can be turned into an entire development environment, ideal for power users who want more than just a text editor.

VS Code and Atom are modern, graphical editors that offer a rich set of features, including extensions, debugging tools, and Git integration, making them favorites among developers.

Why Do Many Devs Prefer Vim?

Despite the wide range of text editors available in Linux, Vim stands out as the preferred choice for many users, especially those who need a lightweight, fast, and highly efficient editing environment.

Vim, an improved version of the classic Vi editor, is available on nearly every Linux distribution and can be used in both graphical and terminal-based environments. Its popularity stems from its exceptional speed and efficiency.

Vim is entirely keyboard-driven, allowing you to perform complex editing tasks quickly without the need for a mouse. This makes it incredibly useful for remote work, where you may have to rely on minimal system resources.

The power of Vim lies in its modal editing system, which separates the text input and command modes, which you’ll learn soon. This lets you execute precise actions with a few keystrokes. Whether you're navigating a file, searching for a string, or performing complex text manipulations, Vim enables you to do it all without taking your hands off the keyboard.

Because Vim (or Vi) is pre-installed on most Linux systems, it’s often the go-to option for developers and system administrators, who rely on its ubiquity and powerful features. In short, Vim’s combination of speed, versatility, and efficiency makes it the editor of choice for many Linux users looking to boost their productivity.

How to Open the Vim Editor

Opening a file in Vim is straightforward and efficient. To start editing any file, simply use the following command in your terminal:

vim [filename]

Here, replace [filename] with the name of the file you want to open. If the file doesn't exist, Vim will create a new file with that name. Once executed, Vim will open the file and allow you to start editing right away.

Example:

vim data.txt # A file that doesn't exist yet, so Vim creates a new file named data.txt

When you execute the command vim data.txt, Vim opened a new file named data.txt because a file with this name did not previously exist in the current directory. In Vim, this is indicated by the message at the bottom of the editor, which reads: data.txt [NEW]

If the file you want to edit already exists, you can open it in Vim by using the same command. You’ll be able to see its contents and make edits as needed. If you don’t see the [New] message at the bottom (as shown for new files), it confirms the file already exists.

Modes in Vim

Vim has several modes, but the most commonly used ones are:

• Normal Mode (Command Mode) – Used for navigation and executing commands.

• Insert Mode – Used for typing and editing text.

When you open a file in Vim, it starts in Command Mode by default. This mode allows you to navigate, execute commands, and perform various operations without directly modifying the text. To edit the text in the file, you need to switch to Insert Mode.

What is Command Mode?

Command Mode is the default mode in Vim. In this mode, you can navigate through the file using the arrow keys and cut, copy, paste, or delete the content and execute commands like saving or quitting.

To switch to Command Mode from any other mode, press the Esc key.

Example: If you are in Insert Mode and need to return to Command Mode to save or navigate, press Esc.

In the above image, "hello.txt" 1L, 1B” indicates that the file hello.txt is open and is currently in Command Mode, which is the default mode when you open Vim. 1L Represents 1 line in the file (currently the file is empty, so there’s just one blank line). 1B Represents 1 byte (the file is currently empty)

What is Insert Mode?

Insert Mode allows you to edit or type text in the file, similar to a traditional text editor. You can insert new lines, modify existing text, and make changes directly.

Press i while in Command Mode. This switches to Insert Mode and places the cursor at the current position, allowing you to start typing.

In the above image, “—INSERT—” indicates that the editor has been switched to Insert Mode, allowing you to type and edit text directly in the file.

Quick glance: When you open a file, always check the bottom of the terminal to determine your current mode. If the bottom line displays file-related information, you are in Command Mode. If the bottom line explicitly says -- INSERT --, you are in Insert Mode. If you want to go from Command Mode to Insert Mode: Press i. And from Insert Mode to Command Mode: Press Esc.

Basic Vim Commands

Below are some essential commands to help you manage files efficiently in Vim.

Note: Before using these commands, ensure you're in command mode by pressing Esc.

1. Save Changes

To save the changes made to a file, use the following command:

:w

This writes (saves) the current file without exiting Vim.

2. Save Changes and Quit

If you're done editing and want to save changes and exit Vim simultaneously, use:

:wq

This command writes the changes and then quits the editor.

3. Quit Without Saving Changes

If you wish to exit without saving any changes, you can use:

:q

This command will close the file if no changes have been made since the last save.

4. Force Quit Without Saving Changes

In case you've made changes to the file but want to exit without saving them, you can force quit with:

:q!

The ! overrides any unsaved changes and closes the file immediately.

Cut, Copy, Paste, and Delete Commands (Plus Others)

How to Position the Cursor for Text Manipulation

Before using any of the commands listed below (copy, cut, paste, and delete), it's important to understand where to place the cursor.

• Copy (Yank), Cut, Delete: For most operations, the cursor needs to be placed at the starting point of the text you want to act upon. This means if you're copying or cutting a word, place the cursor at the beginning of the word. If you're working with a line, the cursor should be anywhere on that line. For paragraph-based operations, position the cursor anywhere within the paragraph.

• Paste: The text will be pasted at the cursor's current position. So, ensure your cursor is placed where you want the copied or cut content to appear.

For example, Let’s say I have a file.txt that has the following content -

# file.txt
Hey readers,  
In this blog, we're learning Vim. This file is for demonstration purposes,
where we'll explore various editing commands like cut, copy, paste, and delete. Let's dive in!  

Vim is a powerful text editor that comes pre-installed on most Unix-based systems.
Mastering Vim can significantly boost your efficiency as a developer.  

To start with, let's learn some basic navigation and text manipulation commands.
Stay tuned as we break down each command with examples!

All the commands mentioned below will use this file as reference to explain examples.

1. Copy (Yank)

In Vim, copying is called "yanking." Use the following commands to copy text. The cursor's position is important to ensure the correct text is copied.

2. Cut (Change)

Cutting in Vim is known as "changing" the text. The cut operation replaces the text. Just like with copying, the cursor's position is important when using cut commands.

3. Paste

To paste the copied or cut text, use the following commands. The pasted text will appear at the current cursor position.

4. Delete

Deleting text in Vim allows you to remove unwanted text while remaining in command mode. The cursor must be positioned correctly to delete the intended text. Once deleted, you can still paste the deleted text to a new location.

5. Other Useful Commands

Note that Delete removes text but doesn’t store it in the system clipboard by default. The text goes into Vim’s unnamed register, meaning it can be pasted within Vim but not outside it. Cut explicitly stores text in the clipboard so you can paste it outside Vim as well.

Search and Replace Commands

Vim provides powerful search and replace functionality that allows you to find specific words or patterns and replace them efficiently. Understanding how to search and replace text is key to improving your productivity when editing large files.

Below is a breakdown of the various search and replace commands in Vim.

Search Commands

• Search Forward (/): When you want to search for a word or pattern below the cursor, use the / command. This will search forward in the file.

• Search Backward (?): Similarly, if you want to search for a word or pattern above the cursor, use the ? command. This will search backward in the file.

After performing a search, you can navigate through the search results:

• n: Go to the next match in the same direction (forward if /, backward if ?).

• N: Go to the previous match in the opposite direction (backward if /, forward if ?).

Replace Commands

Once you've located the word or pattern you want to replace, Vim provides several commands for replacing text.

Here’s an example:

In Vim, the /Tanishka pattern searches for an exact, case-sensitive match of the word "Tanishka."

To replace "Tanishka" with another word, like "Linux," you can use the substitution command like this: :s/Tanishka/Linux:

By default, this command replaces only the first occurrence of "Tanishka" in the line where the cursor is located.

If you want to replace all occurrences of "Tanishka" in the same line, you need to add the g (global) flag after the replacement string like this: :s/Tanishka/Linux/g.

This ensures that every instance of "Tanishka" in the current line is replaced with "Linux."

Similarly, the % symbol is used to specify the entire file when performing a substitution. Here's how it works in combination with the substitution command:

1. Replace the first occurrence in each line of the file:

   • :%s/Tanishka/Linux: This command replaces only the first occurrence of "Tanishka" in each line of the file.

2. Replace all occurrences in the entire file:

   • :%s/Tanishka/Linux/g: The addition of the g (global) flag ensures that all occurrences of "Tanishka" in every line of the file are replaced with "Linux."

How to Read Files using more and less

The cat command

The cat command is often used to read file content.

For example:

cat file.txt # Displays content of file

While the cat command is a straightforward tool for viewing file contents, its simplicity often falls short when working with large files or when precise navigation is required. That’s where the more and less commands come into play, offering enhanced functionality for viewing and navigating text efficiently.

The more Command

The more command allows you to view files one screen at a time, making it a significant upgrade from cat when dealing with large files. But it comes with limitations in terms of backward navigation and advanced features.

Here’s the syntax for more:

more [FILENAME]

And here’s an example:

more file.txt # Displays content of file.txt one page at a time

Keys used while viewing:

1. Spacebar: Moves forward by one page

2. Enter: Moves forward by one line

3. b: Moves back by one page

4. q: Quit and exit file content

The less Command

The less command is often considered a superior alternative to more due to its advanced navigation capabilities and flexibility. Unlike more, less allows both forward and backward navigation, making it ideal for reviewing large files or logs.

Here’s its syntax:

less [FILENAME]

And here’s an example:

less file.txt # Displays content of file.txt one page at a time

Keys used while viewing:

1. Spacebar: Moves forward by one page

2. Enter: Moves forward by one line

3. b: Moves back by one page

4. Up/Down arrow key: Moves up or down by one line

5. q: Quit and exit less

The only major difference between the more and less commands is that the less command allows bidirectional navigation, so it’s typically more convenient to use.

Text Filters

A text filter in Linux is a command-line utility that processes text data by modifying, extracting, or formatting it before outputting the result.

Horizontal filters

Horizontal filtering focuses on extracting, manipulating, or displaying specific lines of a file or command output. Common tools include head, tail, and grep.

1. head: The head command displays the first few lines of a file. By default, it shows the first 10 lines. Here’s its syntax:

    head [OPTIONS] [FILENAME]
   

   And here’s an example of how to use it:

    head file.txt # Displays first ten lines from file.txt
    head -n 5 file.txt # Displays first five lines from file.txt
   

2. tail: The tail command displays the last few lines of a file. By default, it shows the last 10 lines. Here’s its syntax:

    tail [OPTIONS] [FILENAME]
   

   And here’s an example:

    tail file.txt # Displays last ten lines from file.txt
    tail -n 5 file.txt # Displays last five lines from file.txt
   

3. grep: The grep command searches for patterns within a file or input. It filters out lines that match a given pattern. Here’s its syntax:

    grep [OPTIONS] [PATTERN] [FILENAME]
   

   Options:

   • -i: Case-insensitive search.

   • -v: Invert the match (exclude matching lines).

   • -n: Show line numbers of matches.

Example

    grep Tanishka data.txt # Displays lines that have 'Tanishka' in them
    grep -i Tanishka data.txt # Displays lines that have 'Tanishka' irrespective of case
    grep -v Tanishka data.txt # Displays lines that do not have 'Tanishka' in them
    grep -n Tanishka data.txt # Displays lines that have 'Tanishka' in them along with number line

Vertical Filters

1. cut: The cut command displays selected parts of lines from each file based on delimiters, byte positions, or character fields. Here’s its syntax:

    cut [OPTION] [FILENAME]
   

   It also comes with various options:

   • -c: Extract specific characters.

   • -b: Extract specific bytes.

   • -d: Specify a custom delimiter (default is tab).

     • cut -d ":" -f 2 file.txt → Second field separated by :.

   • -f: Extract specific fields.

     • cut -d "," -f 1,3 file.csv → Fields 1 and 3 from a CSV.

Example:

    cut -c 1-10 Sample.txt # Displays characters from position 1 to 10
    cut -c 5 Sample.txt # Displays character at position 5
    cut -c 3,5 Sample.txt # Displays characters from position 3 and 5 only
    cut -d " " -f 1 Sample.txt # Displays first field separated by a space
    cut -d " " -f 2 Sample.txt # Displays second field separated by a space
    cut -d " " -f 3 Sample.txt # Displays third field separated by a space
    cut -d " " -f 1-3 Sample.txt # Displays first to third fields separated by a space
    cut -d " " -f 1,3 Sample.txt # Displays first and third fields separated by a space
    cut -d ":" -f 5 /etc/passwd # Displays fifth field separated by : in /etc/passwd

Text Summarization Tool: wc

The wc (word count) command is used to display the number of lines, words, characters, or bytes in a file or input. It is a simple yet powerful utility you can use to summarize text content.

Here’s its syntax:

wc [OPTION] [FILENAME]

And here are its options:

• -l: Displays the number of lines.

• -w: Displays the number of words.

• -c: Displays the number of bytes.

• -m: Displays the number of characters (useful for multibyte characters).

• -L: Displays the length of the longest line.

Example:

wc Sample.txt # Displays line count, word count, and byte count in Sample.txt
wc -w Sample.txt # Displays number of words in Sample.txt
wc -l Sample.txt # Displays number of lines in Sample.txt
wc -L Sample.txt # Displays number of characters in longest line in Sample.txt

wc -c Sample.txt # Displays number of bytes in Sample.txt (Actual storage size)
wc -m Sample.txt # Displays number of characters in Sample.txt (Actual number of characters regardless of enoing)

# ABCD😄
wc -c above.txt # "ABCD" = 4 bytes + "😄" = 4 bytes. 4 + 4 = 8 bytes
wc -m above.txt # "ABC" = 4 + "😄" = 1 byte. 4 + 1 = 5 bytes

Final Words

In this article, we covered the basics of using Vim, a powerful and flexible text editor. We started with how to open a file in Vim and then you learned about its modes. You also learned how to navigate through files, edit text, and use features like search and replace to save time. We also explored a helpful summarization tool.

If you're new to Linux and want to build a strong foundation, check my previous article where I cover the basics of Linux, including essential commands and tips for beginners. It’s a perfect starting point to complement what you’ve learned about Vim here!

Keep practising these commands, and soon they'll become second nature to you. Mastery comes with repetition, so continue experimenting and applying these fundamentals in real-world scenarios.

Stay tuned for more articles. Get ready to take your RHEL skills to the next level.

Let’s connect!

Whether you’re a complete novice exploring Linux for the first time or an experienced professional looking to brush up on your basics, you’re in the right place. This tutorial is your starting point to uncover the power, stability, and versatility of RHEL.

But what makes RHEL stand out in the crowded Linux ecosystem? Why do companies like Google, Amazon, and NASA rely on it? Let’s dive in and explore everything you need to know to begin your journey with Red Hat Enterprise Linux.

What we’ll cover:

1. A Little Backstory

2. What Makes Linux Special?

3. Why Red Hat Enterprise Linux?

4. How to Set Up Your Practice Environment for Linux Commands

5. Introduction to Basic Linux Commands

A Little Backstory

Have you ever wondered where it all began? Before there was Linux, there was UNIX, a revolutionary operating system created in the 1970s that changed the way computers worked. Designed for stability, multitasking, and scalability, UNIX became the foundation upon which modern operating systems were built.

Fast forward to 1991, when a 21-year-old Finnish computer science student named Linus Torvalds at the University of Helsinki decided to create his own operating system kernel as a hobby project. Little did he know, this hobby would evolve into Linux, a game-changing open-source operating system that would redefine the tech world.

Now here’s the fun part: how did Linux get its name? Originally, Linus wanted to call it “Freax” (a combination of “free,” “freak,” and “Unix”). But when he uploaded the project files to a server managed by his friend Ari Lemmke, Ari thought “Freax” didn’t sound appealing enough. So, without telling Linus, Ari named the directory “Linux” instead — a clever blend of Linus + Unix. And the rest, as they say, is history.

What Makes Linux Special?

Unlike traditional operating systems, Linux was open-source, meaning anyone could view, modify, and distribute the code freely. This sparked a wave of innovation, allowing developers around the world to create their own versions of Linux, tailored to different needs.

What truly sets Linux apart is the global community of developers and enthusiasts who constantly improve and innovate. This collaborative approach ensures that Linux stays at the forefront of technology, evolving with the needs of its users.

Today, Linux isn’t just one operating system — it’s an entire family of distributions (or distros). From user-friendly versions like Ubuntu and Fedora to enterprise-grade solutions like RHEL, there’s a Linux for everyone. In this article, we’ll focus on RHEL and why it’s a great choice for certain projects.

If you want to explore the fascinating variety of Linux distros, you can check out this Wikipedia page on Linux distributions to see just how diverse the Linux ecosystem is.

Why Red Hat Enterprise Linux?

Red Hat Enterprise Linux (RHEL) is like the reliable, no-nonsense friend you call when you're organizing a big, important event.

Sure, you could ask your fun but unpredictable friends (like open-source Linux distros) to help, but there's always a chance they'll forget the chairs or crash halfway through the party.

RHEL, on the other hand, is built for stability and comes with a professional support team that’s on call 24/7 to fix anything that goes wrong. It’s tested thoroughly to make sure it works perfectly with all the tools and gadgets big companies use, so there are no surprises.

RHEL’s blend of reliability, security, performance, and support makes it the go-to operating system for enterprises, cementing its importance in the IT landscape.

Here’s a summary of RHEL’s benefits and features:

1. Enterprise-Grade Stability and Reliability

RHEL is designed to meet the demands of mission-critical workloads, ensuring systems run consistently and predictably. Its long lifecycle support ensures businesses can rely on it without worrying about frequent upgrades or compatibility issues. This makes it an ideal choice for applications where downtime is unacceptable.

2. Comprehensive Security Features

Security is paramount in enterprise environments, and RHEL excels with robust features such as SELinux (Security-Enhanced Linux) and regular security updates. The proactive approach to identifying and addressing vulnerabilities helps organizations comply with industry regulations and maintain the integrity of their systems.

3. Scalability and Performance Optimization

RHEL is optimized to deliver high performance for a wide range of hardware architectures and workloads, including cloud, on-premises, and hybrid setups. Its ability to scale efficiently makes it suitable for small-scale applications as well as large data centers and enterprise-grade workloads.

4. Extensive Ecosystem and Professional Support

RHEL benefits from Red Hat’s extensive ecosystem of certified hardware, software, and cloud providers. Enterprises have access to a wealth of tested and certified solutions, along with 24/7 support from Red Hat. This ensures any technical issues are resolved promptly, minimizing downtime and enhancing productivity.

How to Set Up Your Practice Environment for Linux Commands

Before we jump into learning and practising Linux commands, you’ll need to set up an environment where you can run these commands. Here are three great options to consider:

1. Using the Terminal on Your Linux Machine

If you’re already using Linux, the terminal is your go-to interface for interacting with the system. All Linux commands are executed here, and it’s the ideal environment to start practising.

You can open the terminal and directly type your commands to see them in action.

2. Using VMware or Oracle VirtualBox

If you don’t want to install Linux directly on your main machine, using a virtual machine (VM) is a great solution. Virtualization tools like VMware or Oracle VirtualBox allow you to run a full Linux distribution as a guest operating system without affecting your primary system. This way, you can experiment freely in an isolated environment.

How to use a VM:

• Install VMware Workstation Player or Oracle VirtualBox on your computer.

• Download the RHEL ISO Image. You can obtain the RHEL ISO by following these steps:

  1. Register for a Red Hat Developer Account (it’s free):

     • Go to the Red Hat Developer Program.

     • Create an account (it’s free for individual developers).

     • After registering, sign in to your Red Hat account.

  2. Download the ISO:

     • Visit the RHEL Download Page after logging in.

     • Choose the ISO image for RHEL (you may select the latest version).

     • Click Download and save the ISO file on your local system.

Once your VM is running, you can use it to practice commands and explore Linux.

3. KillerCoda: An Online Linux Environment

If you’re looking for an entirely online solution, KillerCoda is a fantastic option. It provides an interactive Linux terminal right in your browser, so you don’t need to install anything on your local machine.

Visit the KillerCoda website and you will see scenario-based lessons.

Now you should be all set.

Introduction to Basic Linux Commands

One of the key features that makes Linux so versatile is its command-line interface (CLI). This is where you can interact with the system by typing commands. These commands allow you to perform a variety of tasks like managing files, directories, system resources, and much more.

Now, we’ll explore some essential Linux commands that every beginner should know. These commands are simple yet powerful tools that can help you navigate and manage your Linux environment efficiently.

Basic Linux Commands

1. echo

The echo command is used to display text or variables to the terminal. It is one of the most commonly used commands in Linux and is helpful for displaying messages, variable values, and even system information.

echo syntax:

echo [OPTION] [STRING]

Example:

echo Hello # Prints 'Hello' on terminal
echo -n Hey # Does not output a trailing newline

name="Tanishka"
echo "Hello, $name" # Prints variables

Option -e allows echo commands to enable escape sequences.

Here are some other options you can use with echo:

1. \n – New line: Moves the output to the next line.

2. \t – Tab: Adds a tab space.

3. \v – Vertical Tab: Adds a tab as the cursor moves to the next vertical position.

4. \b – Backspace: Removes the last character.

5. \\ – Backslash: Prints a backslash.

Example:

echo -e "Hello World\nThis is a new line."
# Hello World
# This is a new line.

echo -e "Hello World\tThis is tabbed."
# Hello World    This is tabbed.

echo -e "Hello\vWorld\vThis is vertically spaced."
# Hello
#       World
#             This is vertically spaced.

echo -e "This is a backslash: \\"
# This is a backslash: \

2. whoami

The whoami command is used to display the username of the currently logged-in user.

whoami syntax:

whoami

Example:

whoami #tanishkamakode

3. pwd

The pwd command is used to display the current working directory.

pwd syntax:

pwd [OPTION]

Example:

pwd # /home/tanishkamakode
pwd -L # Displays logical current working directory i.e. shows symlinks (shortcut path ,if exists)
pwd -P # Displays physical current working directory i.e. shows resolved path (original path of shortcut ,if exists)

4. ls

The ls command is used to list the files and directories in the current working directory or specified directory.

ls syntax:

ls [OPTION] [PATH]

Example:

ls # Lists files and directories at current working directory

Here are some options you can use with ls:

• ls -l: Lists detailed information about files and directories

• ls -lh: Lists detailed information about files and directories with size in human readable format

• ls -a: Lists all hidden files

• ls -R: Lists recursive content of directory

5. date

The date command is used to display or set the system date and time.

date syntax:

date [OPTION] [FORMAT_SPECIFIER]

Example:

date # Displays current date and time
date +"%d/%m/%Y" # Displays date month year
date +"%H:%M:%S" # Displays hours minutes seconds
date -u # Displays date in UTC time
date --set "2024-06-05" # Sets date to given YYYY-MM-DD
date -d "yesterday" # Displays yesterday's date
date -d "tomorrow" # Displays tomorrow's date
date -d "7 days" # Displays date of 7 days from today

Options you can use with the date command:

1. -u: Displays date and time in UTC.

2. -d: Displays or sets the date/time to a specific string (e.g., "yesterday", "7 days ago").

3. %d: Day of the month (01 to 31).

4. %m: Month of the year (01 to 12).

5. %y: Last two digits of the year (00 to 99).

6. %Y: Full year (for example, 2025).

date -u # Displays date in UTC time
date -d "yesterday" # Displays yesterday's date
date -d "tomorrow" # Displays tommorow's date
date -d "7 days" # Displays date of 7 days from today
date +"%d/%m/%Y" # Displays date month year
date +"%H:%M:%S" # Displays hours minutes seconds

6. cal

The cal command is used to display calendar details. If no options are given, the current month is displayed.

cal syntax:

cal [OPTIONS]

Example:

cal # Displays current month calendar
cal --highlight # Highlights current date

Options you can use with the cal command:

1. --highlight: Highlights the current date in the calendar.

2. -3: Displays the previous, current, and next month.

3. -m: Displays the current month in a multi-line format.

4. -y: Displays the calendar for the entire year.

5. -A [N]: Displays N months ahead of the current month.

6. -B [N]: Displays N months before the current month.

7. cal [year]: Displays the calendar for the entire year.

8. cal [month] [year]: Displays the calendar for the specified month and year.

cal 2024 # Displays the calendar for all months of 2024
cal 06 2024 # Displays the calendar for the 6th month (June) of 2024
cal -m # Displays the current month in multi-line format
cal -A 3 # Displays the 3 months ahead of the current month
cal -B 2 # Displays the 2 months before the current month

7. nl

The nl command is used to add line number to file content.

nl syntax:

nl [OPTIONS] [FILENAME]

Example:

nl file.txt # Displays file content with line numbers
nl -b a file.txt # Numbers all lines
nl -b t file.txt # Number non-empty lines only
nl -s ') ' file.txt # Adds a separator between the line number and the content -
# 1) First line
# 2) Second line

As you can see in the code above, there are other options you can use with the nl command, too.

File Creation and Handling Commands

1. touch

The touch command is used to create an empty file or update the last modified time if a file exists.

touch syntax:

touch [OPTIONS] [FILENAME]

Example:

touch file.txt # Creates a single file - file.txt
touch file1.txt file2.txt file3.txt # Creates multiple files
touch file{1..10}.txt # Creates files with given range names (file1.txt file2.txt upto file10.txt)

2. cat

The cat command concatenates files and also displays the content of files.

cat syntax:

cat [OPTIONS] [FILENAME]

Example:

cat file.txt # Displays content of file.txt
cat file1.txt file2.txt > merged.txt # Overrides content of two files in merged.txt
cat file1.txt >> file2.txt # Appends content of first file to second file
cat -n file.txt # Displays the content along with line numbers

cat > file.txt OR cat >> file.txt # > for overriding, >> for appending
# This allows you to create a new file with a prompt to enter the content
# If file already exists, teminal will read the content you enter.
# Once you’re done with writing content,
# press Ctrl + D (detach).
# Or Ctrl + C but make sure you enter this on new line
# or else current line content will not be appended to the file.

Directory Creation and Handling

1. mkdir

The mkdir command is used to create a directory.

mkdir syntax:

mkdir [OPTIONS] [DIRECTORYNAME]

Example:

mkdir folder # Creates a single directory
mkdir fol1 fol2 fol3 # Creates multiple directories
mkdir fol{1..10} # Creates directories with given range names
mkdir -p /myData/data # Creates nested directories
ls -R /myData # Verify if nested directories created
mkdir -v fol1 fol2 fol3 # Verbose mode i.e confirmation of directory creation on terminal

2. cd

The cd command is used to change the directory – that is, to navigate between directories.

cd syntax:

cd [DIRECTORY]

Example:

cd myFolder # Relative path, starting from current directroy
cd /home/myFolder # Absolute path, starting from root /
cd .. # Goes to one level above current directory
cd ../.. # Goes to two level above current directory
cd OR cd ~ # Goes to home directory
cd - # Switched to directory you were in previously

Copy, Move, and Remove Files and Directories

1. cp

The cp command is used to copy files and directories from one location to another.

cp syntax:

cp [OPTIONS] [SOURCE] [DESTINATION]

Example:

cp myFile.txt /home/newFolder # Copies myFile.txt to newFolder
cp myFile1.txt myFile2.txt /home/newFolder # Copies multiple files to newFolder
cp -r oldData /home/newData # Recursively copies content of oldData directory to newData directory
cp -i file.txt /home/Folder # Asks for confirmation while overriding file.txt that already exists in Folder
cp -v oldData /home/newData # Verbose output i.e. confirmation of copying the directory 
cp -f file.txt /newFolder # Copies the file forecfully

2. mv

The mv command is used to move files and directories from one location to another. It is also used to rename a file or a directory.

mv syntax:

mv [OPTIONS] [SOURCE] [DESTINATION]

Example:

mv myFile.txt /home/newFolder # Moves myFile to newFolder
mv myFile1.txt myFile2.txt /home/newFolder # Moves multiple files to newFolder
mv -i file.txt /home/sample # Asks before overriding the file.txt that already exists in sample
mv -v oldData /home/sample # Verbose mode i.e. confirmation of moving directory oldData in sample directory
mv oldFile.txt newFile.txt # Renames the file

3. rm

The rm command is used to remove files and directories.

rm syntax:

rm [OPTIONS] [FILENAME OR DIRECTORYNAME]

Example:

rm file.txt # Removes single file
rm file1.txt file2.txt # Removes multiple files
rm emptyDir # Won't work for empty directory (Next command will handle this case!)
rm -r myData # Removed a non-empty directory recursively
rm -r -i myData # Asks for confirmation before deleting each file
rm -r -f myData # Removes a non-empty directory recursively without confirmation
rm -r -f -v myData # Removes a non-empty directory recursively without confirmation in verbose mode

4. rmdir

The rmdir command is used to remove empty directories only.

rmdir syntax:

rmdir [OPTIONS] [FILENAME OR DIRECTORYNAME]

Example:

rmdir emptyDir # Removes empty directory emptyDir
rmdir myDir1 myDir2 myDir3 # Removes multiple empty directories
rmdir myDir # Won't work for non-empty directories (Use 'rm -r dir_name' for this case!)

Final Words

Congratulations! You've successfully learned the basics of Red Hat Enterprise Linux (RHEL) and the essential commands that form the foundation of Linux systems.

Keep practicing these commands, and soon they'll become second nature to you. Mastery comes with repetition, so continue experimenting and applying these fundamentals in real-world scenarios.

Stay tuned for more articles. Get ready to take your RHEL skills to the next level.

Let’s connect!

In this tutorial, we will be covering three essential concepts of React – JSX, components, and props.

To get started, you should be familiar with:

1. JavaScript Basics

2. Destructuring of arrays and objects

3. ES6 modules

So, if you are new to React or want to brush up on the basics, read on.

Before getting started with React concepts, let's learn a bit about JSX - which is what you use to write React code.

What is JSX?

JSX stands for JavaScript XML. It's an extension of the JavaScript language based on ES6. It's translated into regular JavaScript at runtime.

JSX allows us to write HTML in React which makes the process of writing HTML in your React apps much easier.

Why use JSX?

JSX is not mandatory. It is totally up to you whether to use plain HTML or JSX. But the code blocks I'll share below will clarify the differnece between plain HTML and JSX and which one is preferable.

// Plain HTML
const myElement = React.createElement('h1', { style:{color:"green"} }, 'I do not use JSX!');

const root = ReactDOM.createRoot(document.getElementById('root'));
root.render(myElement);

// JSX
const myElement = <h1>I Love JSX!</h1>;

const root = ReactDOM.createRoot(document.getElementById('root'));
root.render(myElement);

As you can see in the first example, using plain HTML makes it a bit more difficult to create elements. We need to use a createElement method, then pass the element along with its style and its value.

On the other hand, JSX makes it much easier by simply using the element tag just as we write HTML and passing its value.

Because of these advantages, I'd strongly recommend using JSX.

JSX Rules

There are few rules to keep it mind while working with JSX:

1. A React component name must be capitalized. Component names that do not begin with a capital letter are treated like built-in components.

2. JSX allows you to return only one element from a given component. This is known as a parent element.

If you want to return multiple HTML elements, simply wrap all of them in a single <div></div>, <React.fragments><React.fragments/>, <></> or any semnatic tag.

const App = () => {
  return
    <div>
      <h1>Hello World!</h1>
      <p>Tanishka here!</p>
    </div>
}

But this won't work, because return would be interpreted as a plain return statement. To avoid that, you need to encapsulate everything inside ( ).

const App = () => {
  return (
    <div>
      <h1>Hello World!</h1>
      <p>Tanishka here!</p>
    </div>
  );
}

Now, this will work perfectly!

3. In JSX, every tag, including self closing tags, must be closed. In case of self closing tags you have to add a slash at the end (for example <img/>, <hr/>, and so on).

const App = () => {
  return (
    <>
      <img src="./assets/react.svg" alt="" />
    </>
  );
}

4. Since JSX is closer to JavaScript than to HTML, the React DOM uses the camelCase naming convention for HTML attribute names. For example: tabIndex, onChnage, and so on.

5. "class" and "for" are reserved keywords in JavaScript, so use "className" and "forHTML" instead, respectively.

How to use CSS in JSX

While working with JavaScript we typically have a HTML file, a CSS file, and a JavaScript file, right? Simple. But while working with React, we use HTML (JSX) and JavaScript in the same file.

To add style to our components, we can either use inline CSS or external CSS.

Let's first see how inline CSS works in React.

JSX represents objects, that is key-value pairs – like a property name and its value. Always write the value in " " as we do in objects.

So when we're adding inline styles to JSX elements, we must add { } for object representation (outer { } is the convention).

const App = () => {
  return (
    <>
      <h1 style={ { color: "Red" } }>Hello World!</h1>
      <p style={ { fontSize: "20px" } }>Tanishka here!</p>
    </>
  );
}

Here, if you look at style in isolation, you'll see it does look like an object:

{
    color: "Red"
}

Basically, use { } to add styles, use key-value pairs, and always write the value in " ".

Now, let's see how to use an external CSS file.

We simply create a .css file and import it in our .jsx file like this:

import './style.css'

/* 
    Your code here
*/

How to use JS in JSX

We might need to use plain JavaScript to add logic to program rendering components. And to add plain JavaScript code in JSX, we need to write it inside curly brackets.

However, whatever we write inside curly brackets must be an expression. Statements are not allowed.

const App = () => {
  return (
    <>
      <h1>My name is {const name = "Tanishka"}</h1>
    </>
  );
}

The above code is invalid.

Now, you might think {const name = "Tanishka"} is also JavaScript. How is this code block not valid? Because it is an initialization of name that is a statement and we cannot write statements inside curly brackets.

We can make a few changes in the above code block and it will be valid:

const App = () => {
  return (
  const name = "Tanishka";
    <>
      <h1>My name is {name}</h1>
    </>
  );
}

We initialized value of name outside the return block and just used the included varibale name inside curly brackets, where name has the assigned value of "Tanishka". So now it is an expression and is valid.

Now that we know how to write code in React, let's learn what to write – that is, React's basic concepts.

What are Components in React?

Components are independent and reusable blocks of code which work in isolation. The main advantage of components is that they help reduce redundancy.

You can think of a component as a lego brick. When you're building a website, you put many of these bricks together to create the whole.

We can classify components into two types: class components and functional components. I won't go into the details here, as that's a topic for another tutorial.

Just know that the downsides of using class components are that they come with a bunch of preloaded stuff inside them whether you want it or not. This makes them a bit more difficult to deal with.

The React team recommends that new apps should be built with functional components and hooks. So, you should really consider the functional component approach when working with a new React project. So that's what we'll focus on here.

How to create a functional component in React

function Greet() {
  return <h1>Hello World!</h1>;
}

OR

const Greet = () => <h1>Hello World!</h1>

Wait, but aren't these just JavaScript functions? YES! Components are basically JavaScript functions which return a single HTML element. Conventionally, arrow functions are widely used.

And what are those funny looking tags? That's called JSX, which you'll learn more about in a minute.

How to nest components in React

In React, we can nest components inside one another. This helps in creating more complex User Interfaces. It also helps in getting rid of redundant code. The components that are nested inside parent components are called child components.

For example:

const Book = () => {
  return (
    <div>
      <h1>Book name : Cracking The Coding Interview</h1>
      <h2>Author : Gayle Laakmann McDowell</h2>
    </div>
  );
};

Here, we have created a Book component. What if we want to create more such instances of the book component? This is when we can use nested components.

const BookList = () => {
  return (
    <div>
      <Book />
      <Book />
    </div>
  );
};

const Book = () => {
  return (
    <div>
      <h1>Book name : Cracking The Coding Interview</h1>
      <h2>Author : Gayle Laakmann McDowell</h2>
    </div>
  );
};

In the above code block, we have created two components, Book and BookList. Book returns a div that has Book name and author name while BookList returns a div that contains two books.

In this way, nesting helps us create multiple instances of a component to create complex User Interfaces easily.

How Props Work in React

Props stand for properties. Props are like function arguments, and you send them into the component as attributes.

When we want to create multiple instances of a single component with various different values, we need to use props.

Let's go with our pevious example of Book and BookList:

For example:

const BookList = () => {
  return (
    <div>
      <Book />
      <Book />
    </div>
  );
};

const Book = () => {
  return (
    <div>
      <h1>Book name : Cracking The Coding Interview</h1>
      <h2>Author : Gayle Laakmann McDowell</h2>
    </div>
  );
};

In this code block, we have hard-coded values of book name and author but that's not really helpful for other books.

We can think of a component like a function and props like arguements of that function. We simply provide some specific values for each component and use those values in the component body.

Let's first see how to pass props:

const BookList = () => {
  return (
    <div>
      <Book bookName = "Cracking The Coding Interview"
      author = "Gayle Laakmann McDowell"/>
      <Book bookName = "The Road to Learn React"
      author = "Robert Wieruch"/>
    </div>
  );
};

Here, we simply created variable-like structures (bookName, author) and assigned their respective values to them. That's it! These are props.

Now, let's see how can we access them, that is use them in the component body:

const Book = (props) => {
  return (
    <div>
      <h1>Book name : {props.bookName}</h1>
      <h2>Author : {props.author}</h2>
    </div>
  );
};

Firstly, we need to use the keyword 'props' in the parameter of an arrow function which will act as an object. Now we can access the props values just like we access object values – object.property.

That's why we used 'props.bookName' and 'props.author'. Every book will get it's respective value by doing this, thus perfectly creating multiple instances of the book component.

You can use props like this, but there's another way of accessing props. For this method, you need to be familiar with the concept of destructuring, that is accessing each and every element of an object.

const Book = (props) => {
  const {bookName, author} = props;
  return (
    <div>
      <h1>Book name : {bookName}</h1>
      <h2>Author : {author}</h2>
    </div>
  );
};

We destructured the 'bookName' and 'author' and we used them as varibles instead of 'props.bookName' and 'prop.author'.

We could have directly detructured props in the parameter section. It would have looked like this:

const Book = ({bookName, author}) => {
  return (
    <div>
      <h1>Book name : {bookName}</h1>
      <h2>Author : {author}</h2>
    </div>
  );
};

It works just the same as the previous method but we just destructure the content of the props in the parameter section instead of doing it by declarations.

Children props

Sometimes, we might come across situations in which we need to add a specific element to a particular instance of a component only. We pass the specific element between opening and closing tags of the component. In those cases, we use children props.

const BookList = () => {
  return (
    <div>
      <Book bookName = "Cracking The Coding Interview"
      author = "Gayle Laakmann McDowell">
          <button> Read Now! <button/>
      < Book />
      <Book bookName = "The Road to Learn React"
      author = "Robert Wieruch"/>
    </div>
  );
};

In the above code block, we want to display a button only for the first book instance. That's why we used a child component by passing the button between opening and closing tags.

Let's see how to access them:

const Book = ({bookName, author, children}) => {
  return (
    <div>
      <h1>Book name : {bookName}</h1>
      <h2>Author : {author}</h2>
      {children}
    </div>
  );
};

We simply add 'children' in the paramters section and then used '{children}' in components wherever we want to place child props. In this case, I wanted to place that button below the information, so I used '{children}' after 'bookName' and 'author'.

This places a child prop between opening and closing tags only when it's specified. This serves our purpose.

When we want an element to be present only for a single instance of the component, we can use children props between component tags. Then again, we can either use props.children or destructure it and use it directly.

Let me show you how it will look:

As you can see, only the first instance has got the button below its information. So this is how children props come in handy.

Key Props

A key is a special attribute you need to include when creating lists of elements in React. We use keys to give an identity to elements in lists. We need to specify an id or any unique value to each instance of a component to keep track of their addition or removal.

When you're chosing a key for the items in lists, try to use a unique id for every instance. If an id is not provided or for some reason you can't use the id, we can go with the index of the list.

const App = () => {
  const numbers = [1, 2, 3, 4, 5];
  return (
    <>
      {numbers.map((number) => {
        return <li>{number}</li>;
      })}
    </>
  );
};

In the above code block, we are simply iterating over a list of numbers. Everything works fine until we open console. It is full of red text - a warning that says - 'Warning: Each child in a list should have a unique "key" prop.'

In this case, we don't have any specified id, so we can use the index of the list by accessing the second argument of the map function, that is index.

const App = () => {
  const numbers = [1, 2, 3, 4, 5];
  return (
    <>
      {numbers.map((number, index) => {
        return <li key={index}> {number} </li>;
      })}
    </>
  );
};

This code block works fine and all warnings are gone now.

Wrapping up

I hope this tutorial has been helpful in getting you started on your React journey. Happy coding !👩🏻‍💻✨