Linux roadmap

The shell is a text-based interface that allows you to interact directly with your operating system using typed commands instead of clicking icons with a mouse. When you open your terminal, you are greeted by a prompt waiting for your instructions. This text-based approach gives you immense speed and precise control over the computer.

For example, instead of opening multiple folders to find a document, you can type a short command to interact with it instantly. This skill forms the foundation of all Linux work because it teaches you how the system interprets your intentions.

Learning the shell matters because servers and cloud computers rarely have graphical screens. Mastering this text window ensures you can comfortably manage systems anywhere.

• The shell accepts typed text commands
• It replaces mouse clicks with precision
• Prompts show the system is ready
• Essential for managing remote servers

Moving around in Linux means navigating through a hierarchical tree of directories, starting from the root folder. You check your current location using a simple command that prints the absolute path on your screen, letting you know exactly where you are sitting in the file system.

To change your location, you use another command followed by the name of the destination folder, much like double-clicking folders on a desktop. If you want to return to your home directory, a shortcut command takes you back instantly.

Knowing how to navigate efficiently prevents you from getting lost in complex folder structures, which is vital when you start configuring applications or writing code.

• Linux uses a tree directory structure
• Check current location with a path command
• Change folders using the change directory command
• Use shortcuts to jump home quickly

Managing files and folders via the command line involves creating, copying, moving, and deleting items using concise text instructions. Instead of dragging and dropping with a mouse, you combine a command with the target file names to perform actions instantly.

For instance, you might create a new empty text file to store notes, or copy an existing script into a backup folder before making edits. Because there is no recycling bin for many command line actions, these tools execute your instructions immediately.

This matters because automation relies on managing files programmatically. Gaining confidence here lets you organise large projects quickly and accurately.

• Create new files using touch or text editors
• Copy and move files with dedicated commands
• Delete files carefully as actions are final
• Use wildcards to target multiple files

In Linux, files and folders that begin with a dot are hidden from normal view to keep your working directories clean and uncluttered. These hidden items typically hold important configuration settings and preferences for your applications and user account.

To see these hidden files, you add a special flag or modifier to your standard directory listing command. For example, your shell settings are often stored in a hidden file within your home folder, allowing your custom preferences to load every time you log in.

Understanding hidden files is crucial because troubleshooting software issues often requires editing these exact configuration files to change how a program behaves.

• Hidden files start with a dot symbol
• They store user and application configurations
• Use a listing flag to reveal them
• Edit them carefully to adjust system settings

Every file and directory in Linux is assigned a specific user owner and a group owner, which forms the bedrock of multi-user security. When you create a file, your user account is automatically recorded as its owner, granting you primary control over its access rights.

Groups allow administrators to bundle multiple users together so they can share access to project folders without making files public to the entire system. For example, web developers might share a group ownership of website files on a shared server.

Understanding ownership matters because it explains why certain users can view or edit files while others cannot, keeping sensitive data protected from unauthorised modifications.

• Every file has a user owner
• Files can also belong to a group
• Ownership dictates primary access rights
• Helps secure multi-user computer systems

Linux permissions break down access into three distinct types: read, write, and execute. Read allows a user to view the contents of a file or list a directory, write lets them modify or delete the file, and execute allows them to run the file as a program.

These permissions are applied separately to the owner, the group, and everyone else on the system. For instance, a script might be fully editable by you, readable by your team group, and completely locked to outside users.

Knowing these three permission types is essential for securing your system and ensuring applications can function properly without exposing private data to risk.

• Read grants permission to view data
• Write grants permission to edit data
• Execute allows running files as programs
• Applied to owner, group, and others

When you need to adjust who can access a file, you use a permission-changing command that accepts either symbolic letters or numerical codes. Numbers represent permission values added together, while letters let you specifically add or remove read, write, or execute rights for the owner or public.

For example, if you write a shell script, you must add execute permission so the system will allow you to run it. If a document is too open, you can remove permissions for everyone else.

This skill matters because setting correct permissions prevents unauthorised users from tampering with important files and keeps your private data secure.

• Change permissions using numbers or letters
• Add execute rights to run scripts
• Restrict access to protect private files
• Applies to owners, groups, and others

Normal user accounts have limited privileges to prevent accidental damage to the operating system files. When you need to install software or change system-wide settings, you must temporarily elevate your powers using a superuser command prefix.

The superuser, often called root, has unrestricted access to every part of the Linux system. By prepending a special authorization command to your regular instructions, the system prompts for your password to confirm you have permission to make these administrative changes.

This matters because protecting the superuser account keeps your operating system safe from malware and mistakes, while still letting authorised administrators maintain the computer.

• Normal accounts have limited system access
• Superuser has full administrative control
• Elevate commands using a special prefix
• Protects system integrity from accidental errors

A process is simply a running instance of a program, such as your text editor, web browser, or background system service. Linux assigns each process a unique identification number and tracks how much central processing unit and memory power it consumes.

By running a process listing command, you can see an overview of everything currently active on your computer. Interactive tools take this further, displaying a live dashboard of resource usage so you can spot heavy applications.

This is vital for performance troubleshooting. If your computer slows down, checking running processes helps you identify which application is hogging your hardware resources.

• Processes are running program instances
• Each gets a unique identification number
• Monitor processor and memory consumption
• Use tools to view live resource usage

Sometimes applications freeze up or refuse to close normally, consuming valuable system resources in the background. When this happens, you can target the frozen application using its process identification number and send a termination signal to shut it down.

Gentle signals ask the program to save data and close gracefully, while stronger signals force the operating system to stop the process immediately. For example, if a background text editor stops responding, you can terminate it instantly from the terminal.

Knowing how to stop stuck programs ensures you can regain control of your computer without needing a hard reboot.

• Target stuck programs using their identification number
• Send polite requests to close gracefully
• Use force signals if applications completely freeze
• Restores system responsiveness without rebooting

Linux manages applications through package managers, which act like secure app stores built directly into the operating system. Instead of hunting for installers online, you use text commands to download, update, and remove software from official, trusted repositories.

The package manager automatically handles dependencies, ensuring all supporting files needed by an application are installed correctly and securely. For instance, installing a web server is handled by a single command that fetches everything required.

This matters because it keeps your software up to date and secure, shielding your computer from fake downloads and unverified third-party installers.

• Use package managers for safe software installation
• Software is fetched from trusted repositories
• Dependencies are handled automatically
• Update and remove apps with simple commands

When you run a command in the terminal, your prompt usually waits until that task finishes before letting you type anything else. By pushing jobs into the background, you can free up your prompt while long-running tasks continue processing.

You can suspend a current task, send it to the background, or bring it back to the foreground whenever you need to check its progress. For example, if you are compressing a large folder, background jobs let you keep using the terminal for other work.

This skill improves your productivity by allowing you to multitask effectively within a single terminal window without opening multiple tabs.

• Free up your prompt while tasks run
• Send active tasks to the background
• Bring background jobs back to foreground
• Great for handling time-consuming terminal tasks

Viewing text files directly in the terminal is an everyday task for system administration and development. Instead of opening a heavy word processor, you can use lightweight commands to print the entire contents of a file, inspect just the first few lines, or view logs as they update in real time.

For example, system administrators frequently check log files to see why a service failed to start. Using quick viewing commands lets them spot errors instantly without cluttering their screen.

This matters because configuration files and system logs are almost always plain text in Linux, making quick-reading tools indispensable for daily work.

• View file contents without graphical editors
• Inspect the beginning or end of files
• Stream log updates in real time
• Essential for checking system logs

When dealing with massive log files or code documents, reading every line manually is impossible. Text searching tools allow you to scan files instantly for specific words, error codes, or patterns, returning only the lines that match your query.

For instance, if a server throws an error, you can search your log files for the word error to pinpoint the exact timestamp and cause. You can even combine search tools with other commands to filter data streams on the fly.

Knowing how to search inside text makes you efficient at debugging applications and finding configuration settings hidden within complex system files.

• Scan large files for specific keywords
• Filter output streams to find relevant data
• Locate error codes in system logs quickly
• Combine with other commands for powerful filtering

Checking network connections helps you verify whether your computer can talk to other machines on a local network or out on the internet. Basic networking utilities let you test reachability by sending quick packets to a server and measuring the response time.

You can also inspect your own network interfaces to check your assigned internet protocol address and connection status. For example, if a website fails to load, testing network reachability helps you figure out if your internet connection is down.

This is vital for troubleshooting connectivity issues, ensuring your computer can communicate smoothly with local servers and remote resources.

• Test reachability of other computers
• Measure response times for network packets
• Inspect local network interface addresses
• Troubleshoot basic internet connection issues

Downloading files directly from the command line is essential when working with remote servers that lack a web browser. Networking tools let you fetch web pages, grab installation scripts, or download software packages straight into your current folder using simple text links.

For example, you might pull down a security update script from a repository directly onto a remote cloud server. These tools handle data streams efficiently and show progress bars right in your terminal window.

This matters because it bridges the gap between the web and your local command line, allowing you to automate software acquisition without manual browser interaction.

• Fetch files and web pages via terminal
• Ideal for servers without web browsers
• Download scripts and packages directly
• Track download progress with output bars

System services are background programs that start automatically when your computer boots up, handling tasks like web hosting, printing, and network management. You use service control commands to start, stop, restart, or check the status of these background daemons.

For example, if you make changes to a web server configuration, you must restart the service for the new settings to take effect. Checking status reports lets you confirm whether the service is running healthily.

Knowing how to manage services is crucial for anyone maintaining server environments, ensuring critical applications stay online and recover properly from reboots.

• Services run quietly in the background
• Start, stop, and restart daemons easily
• Check live health and status reports
• Essential for maintaining server applications

A shell script is a plain text file containing a sequence of command-line instructions executed one after another. Instead of typing the same commands manually every day, you save them into a script file and run the entire file as a single program.

For instance, you could write a script that backs up your important documents, compresses them, and moves them to an archive folder automatically. The first line of the file tells the system which interpreter to use.

This is your first step into programming and automation. Writing scripts saves time, reduces human typing errors, and standardises repetitive workflows.

• Combine multiple commands into one file
• Automate repetitive daily tasks easily
• Specify the shell interpreter on line one
• Reduce typing errors with saved workflows

Variables and basic logic transform static scripts into smart programs that can adapt to different situations. Variables let you store temporary pieces of data, such as folder names or user inputs, while conditional logic lets your script make yes-or-no decisions based on test results.

For example, your script can check if a backup folder exists; if it does, the script proceeds, and if it does not, the script creates it automatically.

This matters because adding decision-making capability makes your automation robust, preventing errors when system conditions change unexpectedly.

• Store data temporarily using variables
• Add conditional yes-or-no decisions
• Check conditions before running commands
• Make scripts adapt to changing environments

Scheduling tasks allows your computer to run scripts and commands automatically at specific times and dates without requiring you to be at the keyboard. A background scheduler reads a configuration table containing your instructions and triggers them precisely when scheduled.

For example, you can set up a daily task that runs your backup script every night at midnight while you sleep. This ensures routine maintenance happens reliably without manual reminders.

Knowing how to schedule tasks completes your automation toolkit, letting you delegate routine chores to the operating system safely and efficiently.

• Automate tasks to run on a timetable
• Schedule scripts for quiet night hours
• Reliable execution without manual triggers
• Perfect for routine backups and maintenance