DEV Community: Samkeliso Dube

Linux Text Editors: Learning Nano, Vi and Vim as a Beginner

Samkeliso Dube — Mon, 02 Nov 2026 10:21:05 +0000

As part of my Linux learning journey, I spent time practising three terminal-based text editors: Nano, Vi and Vim.

Before this exercise, I understood that text editors were used to create and modify files. However, I wanted to understand how they work and why they are useful when managing Linux systems.

In DevOps, you will often work with configuration files, scripts and application settings. Knowing how to edit files directly from the terminal is therefore an important practical skill.

1. `Nano` : A beginner-friendly text editor

Nano was the first editor I practised.

It is straightforward because you can open a file and start typing without switching between editing modes.

To open a file:

nano notes.txt

I practised creating a file, adding text and saving my changes.

Some useful Nano shortcuts:

Shortcut	Action
`Ctrl + O`	Save the file
`Enter`	Confirm the filename
`Ctrl + X`	Exit Nano
`Ctrl + W`	Search within the file

One thing I learned is that saving and exiting are two separate actions. Pressing Ctrl + O saves the file, while Ctrl + X exits the editor.

2.`Vi` : Understanding editing modes

Next, I moved to Vi.

This editor introduced me to an important concept: editing modes.

When vi opens a file, it starts in Normal (Command) mode. Unlike nano, you cannot immediately start typing text.

The two main modes I practised were:

Normal mode: Used for navigation and executing commands.
Insert mode: Used for typing and editing text.

1. Normal Mode (Command Mode)

This is the mode you start in when opening a file. It is used to navigate through the file and execute commands without directly typing or modifying text.

Command	Action
`h`, `j`, `k`, `l`	Move around the file
`dd`	Delete the current line
`yy`	Copy the current line
`p`	Paste copied text
`u`	Undo the last change
`x`	Delete the character under the cursor

Note:You can perform these actions without entering Insert Mode.

2. Insert Mode

This is the mode used to type, add and modify the actual contents of a file.

To enter Insert Mode, press i while in Normal Mode.

For example, when editing an Nginx configuration file, you can use Insert Mode to change a port from 80 to 8080, add a configuration directive, or modify an existing line.

When you finish editing, press esc to return to Normal Mode.

Some important commands:

Command	Action
`i`	Enter Insert mode
`Esc`	Return to Normal mode
`:w`	Save changes
`:q`	Quit if there are no unsaved changes
`:q!`	Quit without saving unsaved changes
`:wq`	Save and quit

Understanding these commands made working with Vi much easier.

Remember:

Normal Mode = Navigate and execute editing commands.

Insert Mode = Type and modify text.

Vi starts in Normal Mode because it allows you to control and manipulate the file before you begin editing its contents.

3. Vim : Vi Improved

After practising Vi, I installed Vim on my Ubuntu machine.

Vim stands for Vi Improved. It builds on Vi and provides additional capabilities.

I checked the installed version using:

vim --version

My machine reported Vim 9.1.

I also explored some of its capabilities:

Syntax highlighting: Displays different code elements in different colours.
Split windows: Allows you to view multiple editing windows.
Code folding: Allows you to collapse sections of code.
Persistent undo: Can preserve undo history between editing sessions when configured.

I created a small Python file to observe syntax highlighting in action.

4. Why are these editors useful in DevOps?

When managing Linux servers, text editors become useful in everyday tasks.

For example, you might need to:

Edit an Nginx configuration file.
Create a Bash script.
Update application configuration.
Inspect environment settings.
Modify service configuration files.

You may encounter commands such as:

sudo vim /etc/nginx/nginx.conf

This opens an Nginx configuration file for editing with administrator privileges.

What I learned

Nano provides a straightforward editing experience.
Vi introduced me to editing modes and command-based operations.
Vim builds on Vi with additional capabilities.
Saving and exiting are not always the same action.
Terminal-based editing is a useful skill when working with Linux servers.
Practical testing helps us understand differences instead of relying on assumptions.

Learning Linux one concept and one practical exercise at a time.

Linux #DevOps #Vim #LinuxAdministration #LearningInPublic

Getting to Know the Linux Filesystem as a DevOps Beginner

Samkeliso Dube — Sat, 24 Oct 2026 09:47:50 +0000

While working on my EC2 instance, I kept coming across paths like /etc, /var/log, and /usr/share. I wanted to understand what these directories do and when I might need them while managing a Linux server.

To make things easier to understand, I started thinking of the Linux filesystem as a house.

Imagine / (the root directory) as the entire house. Inside the house, there are different rooms, each with its own purpose. You wouldn't keep everything in one room, right?

Linux works in a similar way. It organizes files into directories, and each directory has a particular purpose.

Let's explore the directories I found on my EC2 instance and learn what they do.

Linux Filesystem Hierarchy

1. `/` The Root Directory

Let's start with /, the root directory.

Remember our house analogy? If Linux were a house, / would represent the entire house. All the other directories, such as /home, /etc, /var, and /usr, are located under it.

In Linux, / is the starting point of the filesystem hierarchy. Every file and directory has a place within this structure, even when files are stored on different disks or filesystems.

2. `/bin` Essential Commands

Think of /bin as a cupboard in our house where we keep the basic tools we use every day.

In Linux, /bin contains essential commands that help us perform everyday tasks, such as listing files, copying files, and displaying file contents.

For example:

ls lists files and directories.
cp copies files and directories.
cat displays the contents of a file.

3. `/boot` Boot Files

Think of /boot as the part of our house that holds what we need to get the house up and running.

In Linux, /boot contains files needed to start the operating system. These may include the Linux kernel and files used by the bootloader, which helps the computer load Linux when it starts.

When you switch on a computer, it needs to load the operating system before you can start using it. The files in /boot help make that process possible.

4. `/dev` Device Files

Think of /dev as the place in our house where we find things like the lights, taps, and other equipment we use.

In Linux, /dev contains special files that provide a way for the operating system and applications to interact with devices and certain system resources.

For example:

/dev/sda may represent a disk device.
/dev/null discards anything sent to it.
/dev/tty represents the terminal associated with a process.

These are not ordinary files like a document or a picture. They provide interfaces for working with devices or system resources.

5. `/etc` Configuration Files

Think of /etc as the place in our house where we keep the instructions for how things should work.

In Linux, /etc` contains configuration files that control how the system and its applications behave.

For example:

/etc/ssh/sshd_config contains settings for the SSH server.
/etc/hostname contains the system's hostname.

6. `/home` Users' Personal Directories

Think of /home as the bedrooms in our house, where each person keeps their personal belongings.

In Linux, /home contains personal directories for regular users. Each user can store their own files, documents, and projects there.

For example, if a user named sam has an account on the system, their personal directory might be /home/sam.

7. `/lib` Essential Libraries

Think of /lib as a cupboard where we keep the small parts that help our tools work.

In Linux, /lib contains essential libraries that programs and commands need to run. A library is a collection of ready-made code that a program can use instead of having to do everything from scratch.

For example, a program may need a library to perform certain operations. Without the required library, the program might fail to run.

8. `/media` Removable Devices

Think of /media as the place near the entrance of our house where we connect things we bring from outside, like a USB stick.

In Linux, /media is commonly used as a place to access removable devices, such as USB drives, when they are connected to the computer.

For example, when you plug a USB drive into a Linux computer, the system may make its files accessible through a directory under /media.

9. `/mnt` Temporary Mount Point

Think of /mnt as a temporary place in our house where we put something when we need to use it for a while.

In Linux, /mnt is commonly used as a place to temporarily attach another filesystem so that its files can be accessed.

For example, a system administrator might mount an additional disk at /mnt to access its files.

10. `/opt` Optional Software

Think of /opt as a separate room in our house where we keep additional things we choose to bring in.

In Linux, /opt is commonly used to store additional software, especially applications that are installed separately from the software normally provided by the system.

For example, a third-party application might place its files inside /opt.

11. `/proc` Process and System Information

Think of /proc as a noticeboard in our house that shows us what is happening inside.

In Linux, /proc provides information about running processes and the system itself. The files you see here are virtual files, meaning they are generated by the kernel rather than stored as ordinary files on a disk.

For example:

/proc/cpuinfo shows information about the CPU.
/proc/meminfo shows information about memory.
/proc/1/ contains information about the process with process ID 1.

12. `/root` The Root User's Home Directory

Think of /root as the private bedroom of the person in charge of our house.

In Linux, /root is the home directory of the root user, which is the system's administrator account. It is where the root user can store personal files and other items.

One important thing to remember is that /root and / are different:

/ is the starting point of the entire Linux filesystem.

/root is the home directory belonging to the root user.

13. `/run` Runtime Information

Think of /run as a noticeboard in our house where we keep information about what is happening right now.

In Linux, /run stores temporary system information created since the system started. This information helps programs and services keep track of their current activities.

For example, Linux may store information about running services, process IDs, and communication sockets here.

Unlike /var, which can hold data that remains between reboots, the contents of /run are temporary and are generally cleared when the system restarts.

14. `/sbin` System Administration Commands

Think of /sbin as a cupboard where we keep tools used to maintain and repair our house.

In Linux, /sbin traditionally contains commands used for system administration, such as managing disks, checking filesystems, and maintaining the system.

For example:

fsck checks and can repair filesystems.
reboot restarts the system.

On many modern Linux systems, /sbin is a symbolic link to /usr/sbin.

15. `/srv` Data for Services

Think of /srv as a room in our house where we keep things that we provide to visitors.

In Linux, /srv is intended to hold data served by services running on the system. For example, a server might store files here that it makes available to users over a network.

The exact contents depend on how the system is configured. Not every Linux server uses /srv.

16. `/sys` System and Device Information

Think of /sys as a noticeboard in our house that tells us about the equipment we have and how it is connected.

In Linux, /sys provides information about devices, drivers, and parts of the kernel. Like /proc, it contains virtual files rather than ordinary files stored on disk.

For example, Linux can use /sys to expose information about storage devices and network interfaces.

17. `/tmp` Temporary Files

Think of /tmp as a table in our house where we put things we need for a short time.

In Linux, /tmp is used to store temporary files created by programs and users while they work.

For example, an application might create a temporary file while processing information and no longer need it afterward.

Files in /tmp may be deleted automatically, including during a system reboot, depending on how the system is configured. Therefore, it is not a good place to keep important files permanently.

18. `/usr` Programs and Shared Resources

Think of /usr as a part of our house where we keep many of the tools and resources we use.

In Linux, /usr contains many programs, libraries, and shared files used by the system and its applications.

For example:

/usr/bin contains many commands and programs.
/usr/lib contains libraries used by programs.
/usr/share contains shared files, such as documentation and other resources.

When I explored my Amazon Linux EC2 instance, I also came across /usr/share/nginx/html/ in the Nginx logs. On my instance, this was the directory Nginx was trying to access for website files.

The web root can vary depending on the Nginx configuration. For example, some Ubuntu setups commonly use /var/www/html/.

19. `/var` Variable Data

Think of /var as a storage room in our house where we keep things that change or grow over time.

In Linux, /var contains data that programs and services create or update while the system is running.

For example:

/var/log stores log files that help us understand what is happening on the system.
/var/lib stores data that applications and services need to keep.
/var/cache stores temporary data that can be reused to make things faster.
/var/tmp stores temporary files that may need to remain available longer than files in /tmp.

Why Understanding the Linux Filesystem Matters in DevOps

As I continue learning Linux and working with cloud servers, understanding the filesystem helps me know where to look when I need to investigate an issue.

For example, if I need to check configuration settings, I know to start with /etc. If I want to investigate logs, /var/log is a useful place to look. If I need to understand how a program or service is running, directories such as /proc can provide helpful information.

I'm learning that working with Linux isn't just about memorizing commands. It's also about understanding how the system is organized and knowing where to look when something goes wrong.

I'm still learning, and exploring these directories on my EC2 instance has helped me connect Linux concepts with practical experience.

One step at a time, one directory at a time.

linux #devops #beginners #aws

Linux Architecture for Beginners: Understanding the Layers Behind the Commands

Samkeliso Dube — Sat, 17 Oct 2026 07:12:42 +0000

When I started learning Linux, I wanted to understand what it is and why it is important in DevOps.

After exploring the basics, my next step was to understand Linux architecture.

We often use Linux commands to create directories, manage files, install software, and check services. But have you ever wondered what happens behind the scenes when you type a command into the terminal?

In this article, I'll explain the basic layers of Linux architecture and how they work together.

What Is Linux Architecture?

Linux architecture describes how the different components of a Linux system work together to make the operating system function.

These components have different responsibilities. Some manage hardware resources, while others allow users to interact with the system and run applications.

For beginners, we can understand Linux architecture through four main layers:

Hardware
Kernel
Shell and system utilities
Applications

Let's explore each one.

1. Hardware: The Physical Resources

Hardware refers to the physical components of a computer.

Examples include:

CPU: Executes instructions.
RAM: Holds data and programs that are currently in use.
Storage: Stores the operating system, applications, and files.
Network interface: Allows the computer to communicate over a network.

Linux needs to manage these resources so that applications can run properly.

For example, when you open a program, it needs memory and CPU time. Linux helps manage access to these resources.

2. The Kernel: The Core of Linux

The kernel is the core component of the Linux operating system.

It manages the computer's resources and provides the interface between software and hardware.

Some of its responsibilities include:

Process management: Managing running programs and their execution.
Memory management: Allocating and managing memory.
Device management: Coordinating access to hardware devices.
Filesystem management: Supporting access to files and storage.
Networking: Providing networking capabilities for communication between computers.

For example, when you run a command that reads a file, the program requests access to that file through operating-system interfaces. The kernel helps manage the underlying operations.

As a beginner, remember this: the kernel helps software use the computer's resources safely and efficiently.

3. The Shell and System Utilities

The shell allows us to interact with the operating system by entering commands.

On Ubuntu, a common shell is Bash.

For example, when I open my terminal and type:

pwd

The command prints the path of my current working directory.

When I type:

ls

It lists the files and directories in that location.

Other useful commands include:

cd changes the current directory.
mkdir creates a directory.
cat displays the contents of a file.

These commands are provided by system utilities or other programs, and the shell helps interpret and execute the commands we enter.

Is the Terminal the Same as the Shell?

Not exactly.

The terminal is the interface where we enter and see text. The shell is the program that interprets the commands we type.

Think of the terminal as the place where you communicate and the shell as the program that understands your instructions.

4. Applications

Applications are programs that perform tasks for users or other software.

Examples include:

Nginx, a web server.
MySQL, a database management system.
Docker, a platform for running applications in containers.
Text editors and browsers.

Applications rely on operating-system services and resources to do their work.

For example, Nginx can serve web pages to visitors. Linux provides the networking and other system resources that Nginx needs to operate.

How Do These Layers Work Together?

Let's use a simple example.

Imagine that I open a Linux terminal and type:

ls

Here is a simplified explanation of what happens:

I enter the command in the terminal.
The shell interprets the command and runs the ls program.
The program requests information about the directory.
The kernel helps provide access to the filesystem and the required information.
The program displays the results in the terminal.

This example shows that even a simple command relies on different components working together.

Where Do Daemons Fit Into Linux Architecture?

After exploring the main layers of Linux architecture, I wanted to understand where background services fit into the picture.

The kernel manages system resources, while applications use those resources to perform different tasks. However, not everything on a Linux system requires a user to open a terminal and run a command.

This is where daemons come in.

A daemon is a process that runs in the background to provide a service or perform tasks. Daemons rely on the Linux kernel to access system resources and carry out their work.

For example:

sshd handles incoming SSH connections.
cron runs scheduled tasks.
nginx can run in the background to serve web pages.

To explore this practically, I checked the status of the cron service on my Ubuntu system:

systemctl status cron

The output showed:

Active: active (running)

This told me that the cron service was running at the time I checked it.

This helped me connect the theory to practice. Daemons are not a separate architectural layer; they are background processes that rely on the kernel and other system components to perform their tasks.

Why does this matter in DevOps?

When an application or service fails on a Linux server, knowing how to check its status and understand how background processes work gives us a starting point for troubleshooting.

I'm learning that Linux is not just about the commands we enter. It's also about understanding the processes and services working behind the scenes.

Final Thoughts

Today, I explored Linux architecture and learned how hardware, the kernel, the shell, system utilities, and applications work together.

I also explored daemons and how background services help a Linux system perform tasks without requiring constant interaction from the user.

I'm beginning to understand that building a strong DevOps foundation means knowing not just which command to run, but also what happens behind the scenes.

This is another step in my journey of rebuilding my DevOps knowledge, one concept at a time.

If you're also learning Linux, I'd love to hear: **Which Linux concept took you some time to understand when you first started?

Linux #DevOps #CloudEngineering #LearningInPublic

Starting My DevOps Learning Journey: Understanding Linux

Samkeliso Dube — Fri, 16 Oct 2026 09:01:42 +0000

Introduction

Hello everyone! 👋

I'm starting to share my DevOps learning journey here on Dev.to.

I've been learning about cloud engineering and DevOps, and I'm currently revisiting the fundamentals to strengthen my understanding of the technologies behind modern applications and infrastructure.

As I continue learning, I want to document what I discover, share concepts in a beginner-friendly way, and learn from others in the tech community.

For my first article, I'm starting with Linux.

What is Linux? Why do we use it? What are Linux distributions? And why is Linux an important skill for anyone learning DevOps?

1. What Is Linux?

Linux is an open-source operating system kernel.

Let's break that down.

An operating system (OS) is software that manages a computer's resources and allows applications to run. Examples include Windows, macOS, and Linux-based operating systems.

The **kernel **is the core part of an operating system. It helps software communicate with the computer's hardware and manages resources such as the CPU and memory.

For example, when you open an application, it needs memory and processing power to work. The kernel helps manage those resources.

Linus Torvalds began developing Linux in 1991. Linux became open-source software, allowing developers to study its source code, modify it, and share it according to its licence.

Over time, developers combined the Linux kernel with other software and tools to build complete operating systems for different purposes.

These are called Linux distributions, also known as Linux distros.

Let's look at some popular distributions and what they are used for.

2. What Are Linux Distributions?

A Linux distribution combines the Linux kernel with other software and tools to create a usable operating system.

Think of distributions as different versions of Linux, each designed to meet different needs.

Here are some popular examples.

Popular Linux distributions and their uses

1. Ubuntu

Ubuntu is a popular Linux distribution that is relatively easy to learn, great for beginners
It is used on personal computers, servers, and cloud platforms such as AWS.

2. Debian

Debian is a Linux distribution known for its stability.
It is commonly used for servers and can also be used on personal computers.

3. Red Hat Enterprise Linux (RHEL)

RHEL is designed for businesses that need a professionally supported operating system.
It is used to run business applications and servers.

4. Fedora

Fedora often introduces newer software and technologies.
It is used by developers and people who want to explore modern Linux features.

5. Amazon Linux

Amazon Linux is provided by AWS and is designed for use in the AWS cloud.
For example, you can use it to run applications on an Amazon EC2 virtual server.

6. Kali Linux

Kali Linux includes tools used for security testing and ethical hacking.
Security professionals use it to test systems they have permission to assess

Which distribution should a beginner start with?

Ubuntu is a good starting point because it is beginner-friendly and has plenty of learning resources. As you progress in DevOps, you can explore Amazon Linux and other distributions.

3. Why Do We Use Linux?

You might be wondering, why do so many people and companies use Linux?

Linux has several advantages that make it useful for everyday computing, servers, and cloud infrastructure.

Open source

Linux is open source, meaning people can study its source code, modify it, and share it according to its licence.
This allows developers around the world to contribute to its development.

Stability and reliability

Imagine a website that needs to be available day and night. The server running that website needs an operating system that can support it reliably.
Linux is widely used on servers because it can run for long periods when properly configured and maintained.

Security and permissions

Linux allows administrators to control who can access files and perform certain actions.
For example, not every user should be allowed to change important system files. Linux permissions help control that access.

Efficient resource management

Linux can run on small devices, personal computers, and powerful servers.
It can also run without a graphical desktop, which is useful when managing servers remotely reducing unnecessary overhead.

Automation

Imagine having to perform the same task on 20 servers manually. That could take a lot of time.
Linux provides tools such as Bash that allow you to write scripts to automate repetitive tasks.

Cloud compatibility

Cloud platforms such as AWS and Azure allow you to create virtual machines running Linux.
This means you can use Linux to host websites, run applications, and manage cloud infrastructure.

These advantages make Linux useful across many areas of technology. But why is it particularly important for DevOps engineers?

4. Why Do DevOps Engineers Need Linux?

DevOps brings software development and IT operations together to help teams build, test, release, and operate software more reliably.

Linux is important in this work because many applications and infrastructure tools run on Linux-based systems.

Let's look at some practical examples.

1. Managing servers

A DevOps engineer may need to connect to a remote Linux server, check disk space, inspect files, or investigate why an application is not responding.

For example, these Linux commands are useful:

ls - lists files and directories.
df -h - shows disk space usage.
free -h- shows memory usage.

Learning these commands helps you understand what is happening on a server.

2. Troubleshooting applications

Imagine that you deploy an application to a Linux server, but the application is not responding.

You may need to check whether the application is running, inspect its logs, check the port it uses, verify file permissions, or investigate network connectivity.

Linux knowledge helps you investigate these problems instead of guessing.

3. Writing automation scripts

DevOps engineers use tools such as Bash to automate repetitive tasks.

For example, you could write a script to check whether a service is running or automate part of an application deployment.

Instead of repeating the same commands manually, you can create a reusable process.

4. Working with Docker and containers

Docker is used to package applications and their dependencies into containers.

Many containers use Linux-based environments. Understanding Linux processes, filesystems, permissions, and networking helps you troubleshoot container-related problems.

5. Working with Kubernetes

Kubernetes manages containerised applications across a group of machines called a cluster.

Many Kubernetes worker nodes run Linux. Linux knowledge is useful when investigating application failures, resource problems, and networking issues.

6. Managing cloud infrastructure

When you create a Linux virtual machine on AWS or Azure, you may need to connect using SSH, install software, configure services, and secure the machine.

Cloud platforms provide the infrastructure, but Linux knowledge helps you manage the operating system running on it.

7. Using CI/CD pipelines

Continuous integration and continuous delivery (CI/CD) pipelines automate activities such as building, testing, and deploying software.
Many pipeline jobs execute shell commands in Linux environments. Understanding Linux makes it easier to read pipeline scripts, diagnose failed jobs, and automate deployments.

8. Working with Terraform and Ansible

Terraform and Ansible are tools commonly used in DevOps.

Terraform helps provision infrastructure, such as creating a virtual machine. Ansible can then configure that machine by installing software and setting up services.

Understanding Linux helps you troubleshoot the systems these tools manage.

The key lesson: Linux is not just about learning commands. It helps you understand the systems on which applications run and gives you practical skills for troubleshooting and automation.

Conclusion

Linux is more than a collection of commands. It is a foundation for understanding how computers run applications, manage resources, and support modern infrastructure.

As I continue my DevOps learning journey, I'm starting with the fundamentals because understanding the foundation makes it easier to understand the tools built on top of it.

My goal is not simply to memorise commands. I want to understand what they do, when to use them, and how they help solve real-world problems.

This is just the beginning, and I look forward to sharing more as I continue learning.

One step at a time, one concept at a time. 🌱

What Linux distribution did you start with, and which one do you use today? I'd love to learn from your experience.

Linux #DevOps #CloudComputing #LinuxForBeginners

DEV Community: Samkeliso Dube

Linux Text Editors: Learning Nano, Vi and Vim as a Beginner

1. Nano : A beginner-friendly text editor

2.Vi : Understanding editing modes

3. Vim : Vi Improved

4. Why are these editors useful in DevOps?

What I learned

Linux #DevOps #Vim #LinuxAdministration #LearningInPublic

Getting to Know the Linux Filesystem as a DevOps Beginner

Linux Filesystem Hierarchy

1. / The Root Directory

2. /bin Essential Commands

3. /boot Boot Files

4. /dev Device Files

5. /etc Configuration Files

6. /home Users' Personal Directories

7. /lib Essential Libraries

8. /media Removable Devices

9. /mnt Temporary Mount Point

10. /opt Optional Software

11. /proc Process and System Information

12. /root The Root User's Home Directory

13. /run Runtime Information

14. /sbin System Administration Commands

15. /srv Data for Services

16. /sys System and Device Information

17. /tmp Temporary Files

18. /usr Programs and Shared Resources

19. /var Variable Data

Why Understanding the Linux Filesystem Matters in DevOps

linux #devops #beginners #aws

Linux Architecture for Beginners: Understanding the Layers Behind the Commands

What Is Linux Architecture?

1. Hardware: The Physical Resources

2. The Kernel: The Core of Linux

3. The Shell and System Utilities

Is the Terminal the Same as the Shell?

4. Applications

How Do These Layers Work Together?

Where Do Daemons Fit Into Linux Architecture?

Final Thoughts

Linux #DevOps #CloudEngineering #LearningInPublic

Starting My DevOps Learning Journey: Understanding Linux

Introduction

1. What Is Linux?

2. What Are Linux Distributions?

Popular Linux distributions and their uses

3. Why Do We Use Linux?

4. Why Do DevOps Engineers Need Linux?

Conclusion

Linux #DevOps #CloudComputing #LinuxForBeginners

1. `Nano` : A beginner-friendly text editor

2.`Vi` : Understanding editing modes

1. `/` The Root Directory

2. `/bin` Essential Commands

3. `/boot` Boot Files

4. `/dev` Device Files

5. `/etc` Configuration Files

6. `/home` Users' Personal Directories

7. `/lib` Essential Libraries

8. `/media` Removable Devices

9. `/mnt` Temporary Mount Point

10. `/opt` Optional Software

11. `/proc` Process and System Information

12. `/root` The Root User's Home Directory

13. `/run` Runtime Information

14. `/sbin` System Administration Commands

15. `/srv` Data for Services

16. `/sys` System and Device Information

17. `/tmp` Temporary Files

18. `/usr` Programs and Shared Resources

19. `/var` Variable Data