LPI Linux Essentials Certification Course and Practice Exams

This lesson provides an overview of Linux, focusing on its distributions, the significance of the Linux kernel, the utility of Linux in embedded systems, and its pivotal role in cloud computing. It's designed to equip learners with a solid foundation in understanding what Linux is, the variety of Linux distributions (like Debian, Ubuntu, Red Hat, CentOS), and how these distributions are applied in different environments, including on servers, desktops, and embedded systems such as Raspberry Pi and Android devices.

In this lesson, you will learn:

- Linux is technically a kernel, which is a core component of an operating system (OS) that interacts directly with hardware.

- The Linux kernel serves as an intermediary between the hardware and the applications running on it, handling direct communication with the hardware.

- The Linux kernel facilitates simplified interaction between applications and different types of hardware, like the sound card.

- While Linux refers to the kernel, it's common for people to describe the Linux distribution, which includes the Linux kernel and a set of software, as Linux.

- An OS, such as a Linux distribution, manages hardware resources and provides an environment for applications to run.

- A Linux distribution, also known as a "distro" or "flavor," varies based on the pre-installed software, such as different web browsers.

- Users modify the default software on a Linux distribution, creating a curated collection of preferred applications.

- This lesson does not provide specific examples of Linux distributions, distros, or flavors.

In this lesson, you will learn:

- Red Hat Enterprise Linux (RHEL) is a major and popular Linux distribution.

- Red Hat utilizes the RPM package format, where RPM stands for Red Hat Package Manager.

- Prior to recent updates, the YUM package manager and command line tool are used to install, update, and remove RPM packages on Red Hat.

- In newer versions of Red Hat, DNF replaced YUM as the package manager.

- The DNF command is now used instead of YUM to handle RPM packages.

- Linux distributions that are based on, derivatives of, or descendants from Red Hat are known as Red Hat-based distributions.

- Examples of Red Hat-based distributions include Scientific Linux, Fedora, CentOS, Oracle Linux, Alma Linux, and Rocky Linux.

In this lesson, you will learn:

- Debian is a major and popular Linux distribution.

- Debian introduced the .deb package format and the apt package manager, a command line tool for managing packages in Debian Linux.

- Apt is used in the installation, updating, and removal of Debian packages.

- Many Linux distributions are based on Debian and therefore referred to as Debian-based distros. Examples include Ubuntu, Linux Mint, Pop!OS, MX Linux, Zorin OS, Linux Lite, and elementary OS.

- Ubuntu, one of the most popular Debian-based distros, releases new versions semi-annually, typically in April and October.

- Ubuntu version numbers reflect the release year and month (e.g., Ubuntu 22.04 released in April 2022).

- Ubuntu releases two types of version: Long-Term Support (LTS) and non-LTS. LTS releases occur biennially and receive five years of support after their release, while non-LTS releases are supported for nine months post-release.

- LTS releases are typically used in enterprise environments requiring long-term stability and support.

- Non-LTS releases, containing newer features and software versions not yet available in LTS releases, are more desirable in personal use or situations where the latest features outweigh long-term support.

In this lesson, you will learn:

- When downloading or installing Linux distributions, you have two primary options: Desktop and Server.

- The main difference between a Desktop and a Server distribution is the user interface.

- Desktop distributions include a graphical user interface and applications for general computing tasks such as web browsing and document editing.

- Desktop distributions are usually used by individuals for personal or work use.

- Conversely, server distributions do not include a graphical user interface by default, focusing instead on hosting websites, running databases, and other server-related tasks.

- This efficiency is achieved by not installing and running a graphical user interface.

- Linux system administrators typically access servers through a command-line interface, using text-based commands for configuring and managing the server, removing the need for a graphical user interface.

In this lesson, you will learn:

- Raspbian is a Linux distribution based on Debian and optimized for Raspberry Pi hardware.

- Raspberry Pi is an affordable single-board computer popular for a variety of projects.

- Not all Linux distributions are based on Debian or Red Hat.

- SUSE Linux Enterprise Server (SLES) is an independent commercial distribution designed for enterprise environments, requiring a paid subscription for official support.

- OpenSUSE is a free, community-driven distribution based on SUSE.

- Android, developed by Google for mobile devices, uses a Linux kernel but is not based on either Debian or Red Hat.

- Android is common on Samsung or Google devices.

In this lesson, you will learn:

- Embedded systems are specialized computing devices carrying out specific functions within a larger system.

- Smart TVs are an example of an embedded system, they use a Linux kernel to offer features such as internet connectivity and running applications such as Netflix.

- Tesla vehicle's in-car infotainment system is another example of an embedded system using a Linux kernel.

- Other devices using Linux embedded systems include refrigerators, washing machines, medical devices, networking equipment, security systems, streaming devices like Roku, drones, robots, game consoles, cash registers, and airplanes.

In this lesson, you will learn:

- The cloud refers to a set of servers or computers owned by a third party, accessed over the internet.

- Cloud servers are rented to run software and store data, avoiding the need for owning, managing, and maintaining physical servers.

- Cloud service providers such as Amazon Web Services (AWS), Microsoft Azure, and Google Cloud Platform (GCP) own and operate numerous powerful servers.

- These physical servers utilize Linux and can simulate smaller servers, known as virtual machines (VMs) or instances.

- Each VM or instance has its own CPU, memory, and storage, similar to a physical computer, but the resources are virtual.

- Users can deploy and use these VMs as if they were their own computer and typically install Linux distros as their operating systems.

- Cloud service providers extend beyond VMs to include things such as storage services, database services, etc.

- Using these services, such as a cloud database, eliminates the need for users to manage the underlying Linux distribution, although the majority of these services still run on Linux.

- Linux is critical to cloud computing as most cloud providers run on Linux-based servers, deploy Linux-based VMs, and provide services running on Linux.

In this lesson, you will learn:

- The Linux kernel is the vital part of an operating system that interacts directly with the hardware.

- It acts as an intermediary between software applications and computer hardware, ensuring effective communication.

- A Linux distribution (distro or flavor) is an operating system that uses the Linux kernel; examples include Red Hat Enterprise Linux (RHEL), Debian, and Ubuntu.

- Distros may differ based on the included software packages and package management systems.

- Embedded systems are dedicated computing devices within larger systems.

- Linux is commonly used in embedded systems due to its versatility and adaptability. It's used in smart TVs, appliances, cars, etc.

- Linux is crucial within cloud computing and is used by major cloud providers such as Amazon Web Services, Microsoft Azure, and Google Cloud Platform.

- Virtual machines deployed on these cloud platforms often run Linux distributions, highlighting Linux's importance in the cloud.

This comprehensive lesson focuses on the fundamentals of open source applications within the Linux environment. It begins by clarifying what applications and open-source software are, emphasizing the contrast between proprietary and open-source models. The lesson highlights the significance of open-source software, offering users the ability to view, modify, and enhance the software according to their needs, a principle strongly advocated by Linux Torvalds, the founder of Linux.

The lesson covers a broad spectrum of applications, from desktop environments like Gnome and KDE Plasma to various Linux-compatible software categories including office suites (LibreOffice), email clients (Thunderbird), web browsers (Firefox and Chromium), and multimedia tools (GIMP, Inkscape, Blender, Audacity). It also delves into server applications, discussing web servers (Nginx, Apache HTTPD), database servers (MySQL, MariaDB), and networking tools.

An important part of the lesson is dedicated to understanding package management on Linux, illustrating how to use commands associated with different Linux distributions to install, update, and remove software packages. This includes a hands-on demonstration using the terminal in Ubuntu and Fedora systems, showcasing real-world applications of the commands.

In this lesson, you will learn:

- Computers can be set up either as desktops or servers, with machines capable of serving both functions.

- Desktops usually have a graphical user interface (GUI) and are equipped with tools needed by the primary user.

- Servers provide services like database services, web services, and storage, usually via a network or the internet to multiple users. They are often managed remotely via a command line interface (CLI) and may not have a GUI installed.

- GUIs, also known as desktop environments, manage user desktop display and respond to requests to run other programs.

- Linux allows users to select from different desktop environments during installation, with Gnome and KDE Plasma being notable examples.

- Different distributions may or may not include a desktop environment by default.

- LibreOffice is the most popular office suite for Linux, consisting of applications parallel to Microsoft Office, such as Writer, Calc, Impress, Draw, Base, Charts, and Math.

- Thunderbird is the most notable email client for Linux, supported by Mozilla and inclusive of features like calendars, task management, and chat.

- Evolution is another popular Linux email client, often used by enterprise users and substitutes Microsoft Outlook.

- Firefox and Chromium are the most popular web browsers on Linux, used for interaction with websites and local information processing.

- Linux distributions offer multimedia tools available in their repositories, including GIMP (similar to Adobe Photoshop), Inkscape, Blender, Audacity, and ImageMagick.

- Users can explore their distribution's repository and community repositories for more free applications.

In this lesson, you will learn:
- Linux servers offer many free tools, applications, and services.

- Web servers are responsible for serving HTML content; these can be for static or dynamic web pages.

- Static web pages display the same content to every visitor without the need for additional processing. A news article is an example.

- Dynamic web pages are generated real time based on user input or other data and are created using server-side scripting languages such as PHP, Python, Perl, or Java.

- NGINX and Apache's HTTP server are popular web servers used on Linux. Apache offers flexibility and has an extensive feature set, while NGINX is known for performance.

- Database server software like MySQL and MariaDB are used to store, organize, and retrieve data. Optional GUI-based tools are available for managing and using MySQL databases.

- Oracle offers two editions of MySQL, the open source and free Community Edition and the commercial Enterprise Edition.

- PostgreSQL, an advanced, open source RDBMS known for its robustness and scalability, is another stable database solution for Linux.

- Linux systems can share files and directories using protocols such as NFS or Network File System Protocol for Linux servers, or Samba for cross-platform sharing with Windows and macOS.

- OwnCloud and NextCloud are open source, self-hosted cloud storage solutions for Linux that serve as alternatives to commercial services like Dropbox or Google Drive.

- Linux servers can also perform network administration, including running a DHCP service for managing IP addresses on a network and DNS, the Domain Name System.

In this lesson you will learn:
- Linux is popular among software developers due to the availability of various tools for programming.

- Commonly used programming languages in Linux environments include C, Java, JavaScript, Perl, Shell, Python, and PHP.

- The Linux kernel primarily uses the C programming language, and a C language compiler and libraries are usually included by default.

- C language enables code writing for various operating systems but needs to be compiled for each specific platform.

- Java, another widely used language on Linux, is known for portability and can run on multiple operating systems without modification.

- A C program needs to be compiled into the native code for each operating system, while Java files are universally compatible.

- Despite similarities in names, Java and JavaScript are different languages.

- JavaScript, once primarily used for web page functionalities, has evolved into a language capable of creating entire applications.

- Perl is appreciated for processing and transforming textual data, especially with its powerful regular expression capabilities.

- Regular expressions in Perl work as a smart, flexible search and replace tool, ideal for tasks involving text filtering, parsing, and manipulation.

In this lesson, you will learn:

- Linux distributions come with a default set of software, and additional software can be accessed from the distribution software repository.

- Linux uses a package manager to install, update, and remove applications, as well as keep track of version and dependencies.

- Packages requiring specific libraries or components are automatically downloaded and installed by the package manager.

- Each major Linux distribution has unique package manager tools and commands.

- Red Hat Linux, CentOS, Oracle Linux and Fedora use the rpm, yum, and dnf commands to manage software.

- The 'rpm' command does not perform dependency resolution; users are responsible for ensuring dependencies are satisfied.

- The 'dnf' command, a higher-level tool, does perform dependency resolution and installs necessary packages.

- 'dnf' also sources packages directly from online repositories, eliminating the need for users to download software first.

- Older Red Hat systems may not have the 'dnf' command available, in such cases, users will need to use the original package manager.

In this lesson, you will learn:

- The Ubuntu system's Graphical User Interface (GUI) appearance varies with time, but the basic concepts stay the same.

- A terminal can be opened from the desktop environment by clicking on show applications button (which looks like a grid) at the bottom left and searching for 'terminal'.

- The terminal can be launched by clicking on the application named 'terminal' or hitting enter when it's highlighted.

- The Linux command line can be accessed via the terminal, giving users the benefit of using GUI and command line simultaneously.

- The 'apt' command is used to search for software on a Debian-based system like Ubuntu. For instance, typing 'apt search audacity' will list applications related to Audacity (audio editing software).

- To install a software, the command 'sudo' (superuser do) is prefixed. The sudo command needs the user to have superuser privileges, and prompts for a password to execute the command.

- The apt command shows all programs it will install, the required disk space, and asks for a confirmation to proceed.

- After successful installation, the software (e.g., Audacity) can be located through the show applications menu.

- To uninstall a software, run 'sudo apt remove' followed by the software name (for example, 'sudo apt remove audacity'). The software then can no longer be found in the applications list.

- The shift from Ubuntu-based system to a Red Hat Linux distribution is hinted.

In this lesson, you will learn:

- The user is on Fedora, a Red Hat-based Linux distribution, and is demonstrating how to install Audacity.

- The Fedora graphical user interface is slightly different from Ubuntu's but works similarly.

- Applications can be accessed by clicking on the top left corner of the screen.

- Applications can also be located by typing on the screen or via the show applications menu.

- To start an application, you can simply click on its icon or type its name.

- The terminal application can be launched by typing 'terminal.'

- Software management on a Red Hat-based distribution is performed using the DNF command.

- The user displays how to search for, install, and remove Audacity using the DNF command by typing 'sudo dnf install audacity' and 'sudo dnf remove audacity' respectively.

- The user highlights the need for administrative privileges and a password to install software.

- After successful installation, Audacity is launched via the show applications menu.

- The user affirms that the command line isn't necessary for installing applications on Linux distributions.

- Fedora has an app store-like application for easy software installation.

- To use the app store-like application, it shows typing 'software' brings up an app store with different categories and recommended applications.

- To demonstrate, the user installs GIMP (GNU Image Manipulation Program) using the app store-like application.

- Any application can be searched for and installed using this graphical user interface.

In this lesson, you will learn:

- The lesson covered Linux desktop applications such as LibreOffice, OpenOffice, Thunderbird for emails, Firefox for web browsing, and GIMP for image editing.

- Discussed cloud storage platforms, Nextcloud and Owncloud.

- Explained web servers, specifically Apache HTTP server and Nginx.

- Detailed database servers: MariaDB and MySQL.

- Learnt about NFS for sharing files between Linux systems and Samba for sharing between Linux and Windows systems.

- Introduced several programming languages used on Linux: C, Java, JavaScript, Perl, Shell or Bash, Python, and PHP.

- Discussed managing Linux packages with tools: RPM, YUM, and DNF for Red Hat based distros, and DPKG and APT for Debian based distros.

In this lesson, you will learn:

- Free and open source software (FOSS) is software that is freely distributed, allowing users to use, study, modify, and redistribute it.

- Richard Stallman started the GNU project to create a Unix-like operating system that was free of restrictions and fostered this open-source philosophy.

- Linux, created by Linus Torvalds, is an example of a free Unix-compatible operating system that was later combined with GNU tools to make a complete operating system.

- Major corporations such as IBM, Google, and Intel help in the development of Linux.

- The term "free" in this context doesn't refer to cost, but to the freedom to use, study, change and distribute the software; the term "Libra" is becoming more commonly used to clarify this.

- There are different schools of thought on software development and distribution; proprietary software is commercial and keeps its source code private, while the free software movement and open source initiative advocate for software to be freely shared.

- Software licenses define the terms under which software can be used, modified, and distributed, and include mechanisms such as software copyright and copyleft.

- Common open-source licenses include GNU licenses, the Berkeley Software Distribution (BSD) license, the Apache license, and Creative Commons licenses.

- Despite being often free of charge, open-source software can be monetized through several business models such as crowdfunding and pre-sales, dual licensing, services, Software as a Service (SaaS), peripheral monetization, and obtaining grants, donations, and sponsorships.

- FOSS promotes the four freedoms of running the software for any purpose, studying and changing the source code, redistributing exact copies, and distributing modified versions.

In this lesson, you will learn:

- Linux is based on the principle of free and open-source software.

- The GNU project, led by Richard Stallman at MIT, developed a Unix-like operating system called GNU OS with the aim of sharing and improving software freely.

- GNU stands for GNU's not Unix, marking its opposition to proprietary operating systems such as Unix.

- In 1991, Linus Torvalds created Linux, a Unix-compatible operating system kernel that was later combined with GNU tools to create a full operating system.

- Linux or GNU Linux is a key player in the free and open-source software world and is developed primarily by volunteers and the open-source community.

- Major corporations such as IBM, Google, and Intel employ developers to work on the Linux kernel development team, creating a balance between voluntary and professional contributions.

- The term "free" refers not to cost, but to the freedom to use, modify, distribute, and study the code.

- The term "Libre software" has gained popularity to clarify this definition of "free".

- The term "source" refers to the availability of the human-readable source code along with the software.

- This open-source model allows for software to be freely modified, redistributed, and studied.

- Free and open-source software is often abbreviated as FOSS, or alternatively as FLOSS (Free Libre Open Source Software) since the introduction of the term "Libre".

In this lesson, you will learn:

- Proprietary software is a commercial model, valuing software as intellectual property and distributing under strict licenses to protect creators' rights. The source code is not available to the customer.

- Supporters of the free software movement see proprietary software as morally wrong because it doesn't allow users to see the software's source code, potentially leading to misuse of software by creators.

- The Free Software Foundation promotes four freedoms for software users: running the program as wished, studying and changing the source code, redistributing exact copies, and distributing modified versions.

- A licensing model advocated by the Free Software Foundation aims to ensure both original works and derivative works remain free and open source, and cannot become proprietary.

- The Open Source Initiative represents a third perspective, where developers share their source code and focus on practical benefits like improved software quality, collaboration, and innovation.

- Some open source developers believe that the Free Software Foundation's ideals are too stringent.

In this lesson, you will learn:

- Software licenses define terms and conditions for use, modification, and distribution.

- A Software copyright gives exclusive rights to use, distribute, and modify software to the creator.

- Copyleft licensing allows copyrighted works to be freely used, modified, and shared, extending these rights to any enhancements or adaptations of the original work.

- Most notably strong copyleft license is the GNU General Public License (GPL).

- Permissive licenses are less restrictive than copyleft, allowing derivative works to be used in proprietary projects without needing to be released under the same license.

- The Open Source Initiative is associated with permissive licenses.

- Popular open source licenses include GNU licenses, the Berkeley Software Distribution (BSD) license, the Apache license, and Creative Commons licenses.

- Linux kernel uses the strong copyleft GNU GPL license.

- The Affero GNU Public License (AGPL) applies specifically to hosted software or Software as a Service (SaaS).

- The GNU Lesser Public License (LGPL) is designed to make combining software with different licenses easier.

- BSD licenses are permissive, imposing few restrictions on software use, modification, and distribution.

- Apache license is permissive, offers freedom to use, modify, distribute and sell both the original and modified software versions without significant restrictions.

- Creative Commons licenses cover non-software creations such as music, literature, and visual arts; they follow the principles of sharing, openness, and collaboration like open source software licenses.

- The most restrictive Creative Commons license permits downloading and sharing original work only for non-commercial use, provided the creator is credited and the work is unchanged.

In this lesson, you will learn:

- Open source software is typically offered for free.

- It's possible to earn a living by being an open source developer or by establishing a company around open source products, with Red Hat being a prominent example.

- Crowdfunding or pre-sales are a way to fund open source projects.

- Dual licensing is a strategy where basic software is distributed for free, and another version with advanced features is distributed under a paid license.

- Some entities offer open source software for free, but charge for associated services such as training, installation, custom coding, and support.

- Software as a Service (SaaS) is a common business model. Here, the business hosts and maintains the software for its customers, who access it via a web browser, often via a subscription.

- Peripheral Monetization is a business model where firms earn by selling additional services or products related to the software such as merchandising, certifications, and advertisements.

- Moodle, an open source learning management system, creates and sells a certification program, while Moodle certified individuals sell their services to companies using the Moodle software.

- Acquiring grants, donations, and sponsorships can also be a method for funding open source projects. Such funds can come from universities, non-profit foundations, governments, or individuals.

In this lesson, you will learn:

- Open source philosophy backs the concept of freely accessible software for inspection, modification, and enhancement.

- FOSS stands for Free and Open Source Software, while FLOSS represents Free, Libre, and Open Source Software.

- In the FLOSS context, 'free' signifies freedom of usage, not absence of cost.

- Free Software Foundation promotes four key freedoms: running a program for any purpose, studying and modifying a program, redistributing copies, and distributing copies of modified versions.

- Copyleft licenses, advocated by the Free Software Foundation, mandate that any modifications to the original software must also be freely distributed.

- The Open Source Initiative (OSI) supports licenses permitting free use, modification, and sharing of software, adhering to its definition of open source software.

- Creative Commons licenses are applicable to non-software artistic works such as images, graphics, and text.

- There are several business models that facilitate earning revenue from open source software.

In this lesson, you will learn:

- The lesson covers practical aspects of working on Linux, including navigation around different Linux desktop environments.

- Accessing and working with the Linux command line shell is a major part of the lesson.

- Use of additional Linux applications for work purposes is included.

- It discusses how Linux is used in commercial settings.

- The lesson underlines the need to address security and privacy concerns while using Linux.

- Before utilizing Linux, users need to learn to navigate the system.

- According to the learning series, users need to familiarize themselves with opening a terminal to work on the command line.

- Understanding Linux's strengths and optimal use cases is crucial for those considering a career with Linux or its integration into their organization.

- Additionally, those in IT should be aware of security and privacy concerns as they may be handling sensitive data.

In this lesson, you will learn:

- Linux was developed inspired by the concepts of Unix.

- Unix, an operating system from the 1960s, was strictly command-line based.

- Linux initially also heavily relied on command-line instructions but had a basic GUI.

- Modern Linux versions have a full-featured desktop GUI similar to Windows and Mac OS.

- Linux also offers a powerful shell environment for tasks requiring more control or for preference of command line.

- Bash, based on the Borne shell functionality, is the most commonly used shell on Linux.

- Bash was designed as a free software replacement with improvements from all the shells in Unix.

- Bash was chosen for Linux due to its comprehensive features, compatibility and alignment with the free software movement.

- Bash remains the default shell for many Linux distributions and is the primary choice for most Linux users.

In this lesson, you will learn:

- Linux offers various desktop environments, each with its own appearance and features.

- Popular Linux distributions default to specific desktops, however, users can choose to install different desktop environments.

- The two most commonly used Linux desktop environments are GNOME and KDE, with many others deriving from these two.

- Each desktop environment comes with unique utilities such as terminal emulators, text editors, and file managers.

- The GNOME environment, currently the default for major Linux distributions like Debian, Red Hat, Fedora, and Ubuntu, uses graphics widgets from the GTK toolkit and is programmed in C.

- GNOME layouts are simple, uncluttered, and allow access to common applications like Firefox and various control settings.

- The KDE Plasma desktop environment offers a similar layout to Windows, is feature-rich with expansive configuration options, and was written in C++ with Qt library widgets. 

- Other Linux desktop environment options include the lightweight XFCE, memory-efficient LXDE, and Cinnamon, a fork of GNOME developed for the Linux Mint distribution.

In this lesson, you will learn:

- Terminal emulators are used in desktop environments to run complex administrative tasks and develop software.

- A terminal is a hardware device used to enter data into a computer and display output; it needs to be connected to the main computer or server.

- With the advent of local area networking and broadband internet, terminal emulators have replaced physical terminals.

- Terminal emulator applications allow command line functions with the convenience of GUI features.

- On GNOME, the default terminal emulator is called gnome-terminal; on KDE it's called console. Different Linux distros may use different terminal emulators.

- Terminal emulators can be found in the application menu or by searching for 'terminal' and offer features like text selection, copy-pasting and hyperlink opening.

- The terminal's command line prompt displays the username and the host name of the computer. Non-root users' prompts end in a dollar sign, while root users' prompts end in a pound sign.

- Most Linux desktop environments have a shortcut to open a terminal, typically control + alt + T.

- To allow quick access to the terminal emulator, you can pin it to the dash or dock. This can be done by right-clicking the terminal's icon and selecting 'pin to dash'.

- On the Fedora desktop system using KDE plasma, the process is similar; terminal can be pinned to the dash by first opening the terminal, then right-clicking on the icon, and selecting 'pin to dash'.

- Terminal emulator applications can be quickly reopened from the dash if they are pinned.

In this lesson, you will learn:

- A TTY (Teletypewriter) is a terminal, terminal interface, or a text-based interface allowing users to interact with an operating system.

- TTYs can be used to send and receive typed messages via different communication channels like telephone lines.

- The TTY term predates computers, and was adapted to allow data transfer to computers.

- Virtual TTYs can be accessed with certain keyboard commands combining CTRL-ALT with function keys. For example, CTRL-ALT-F1 for virtual TTY 1, CTRL-ALT-F2 for virtual TTY 2, etc.

- The assignment of virtual TTYs can differ between system distributions.

- Certain TTYs are reserved for text-based terminals, enabling non-graphical interactions with a system shell.

- Using different virtual TTYs allow one to work on multiple tasks at the same time.

- Modern Linux desktop users often use multiple instances of a terminal emulator application or tabs within the application, instead of relying heavily on virtual TTYs.

- Virtual TTYs are particularly useful while troubleshooting, especially issues with booting a Linux system or when the system can't be accessed over the network.

- Cloud providers frequently provide access to virtual TTYs to access a Linux system from the command line. This is particularly helpful for troubleshooting.

In this lesson, you will learn:

- Linux offers a broad range of open-source software for various tasks.

- LibreOffice Impress, a part of the LibreOffice suite, is similar to Microsoft PowerPoint and allows creation of slides, attractive advertisements, and brochures.

- Impress uses the Open Document Standard and can also read and write files in Microsoft PowerPoint format.

- Alternative presentation software in Linux include Beamer and Reveal.js, which are aimed at mathematical and scientific presentations, and interactive presentations using HTML and CSS respectively.

- Linux supports popular open source project management software like Project Libra and GanttProject, which offer alternative features to Microsoft Project.

- Linux has a strong presence in the server market due to its reliability, flexibility, cost-effectiveness, and high performance. Majority of web servers are powered by Linux.

- Linux is popular for cloud services largely because its built-in features support running of applications in containers isolated from other users. Open source software like OpenStack helps manage these cloud applications.

- Cloud services include different business models like Infrastructure as a Service (IaaS), Platform as a Service (PaaS), and Software as a Service (SaaS).

- In IaaS, clients rent computing facilities from a provider but are responsible for installing and maintaining software on the rented systems.

- Virtual machines on a server or cluster of servers are managed by a software application known as a hypervisor. Common Linux hypervisors include Zen, KVM, and VirtualBox.

- PaaS provides both hardware and software tools. Examples include Heroku.

- In SaaS, clients use software in the cloud without administering either the hardware or the software. Examples include Shopify, Salesforce, and Zendesk.

- Linux is popular among software developers due to its reliability and wide range of available development tools.

- Continuous integration, a key tactic in software development, is easily automated in Linux.

In this lesson, you will learn:

- Websites with URLs starting with HTTP use an insecure transmission protocol; those beginning with HTTPS use encrypted transmission with Certificates.

- Certificates, which must be renewed regularly, help ensure the site is legitimate.

- Many browsers display a lock symbol for secure sites showing certificate details.

- Cookies are data pieces stored in a web browser and sent to the websites every visit. They help with functions like Keeping users logged in or saving shopping cart items, but can be used for targeted advertising.

- Users can adjust browser settings to disallow third-party cookies, enable 'Do Not Track', or open a private window for increased privacy. However, these actions have limitations, such as sites ignoring 'Do Not Track' requests and private windows not preventing malware or hiding browsing activity from ISPs or employers.

- Cookie managers offer finer control over stored cookies.

- Important password dos and don'ts include: don't use obvious combinations or personal information, don't reuse the same password, and never share your password. Instead, use strong, long passwords combining letters, numbers, and punctuation symbols.

- Password managers, like KeePass or Bitwarden, store passwords in an encrypted form and provide a more secure, convenient way to handle passwords.

- Passwords can be generated using a mnemonic system or a random password generator typically provided by password managers.

In this lesson, you will learn:

- SSH is a tool used for establishing a secure connection with a remote machine via command line.

- It involves generating a pair of keys, a public key and a private key.

- Private key is kept on the user's computer and encrypted to identify the server.

- The public key is stored on both the user's and remote computer for validation and decryption of communications.

- Encryption is a mathematical process used to protect sensitive data during transfer over a network.

- The current standard protocol for encryption on the internet is Transport Layer Security (TLS), an upgrade from Secure Socket Layer (SSL).

- TLS is used by HTTPS and most email servers for encryption. It also authenticates parties and ensures messages are not tampered with in transit.

- The most common standard for file and email encryption is OpenPGP, using public and private keys and a cryptographic hash for securing data.

- GNU-PG is a free and open source implementation of OpenPGP.

- Disk encryption, specifically block device and stacked encryption, is recommended for platforms storing sensitive data.

- Block device (or whole disk) encryption encrypts the total disk content, sector by sector. Linux Unified Key System (LUX) is a disk encryption specification.

- Stacked encryption allows selective encryption of files and directories without needing root or super user credentials.

- Disk encryption software includes DM-Crypt for block device encryption, ENCFS for stacked encryption, and VeraCrypt for media and file encryption; compatible with Linux, Windows, and macOS.

In this lesson, you will learn:

- Two methods to interact with Linux systems: graphical user interface or desktop environment and the command line interface (CLI).

- Two common Linux desktop environments: Gnome and KDE.

- Accessing command line via terminal emulator application within graphical user interfaces.

- Accessing command line interface also possible through virtual TTYs.

- Explanation about the use of Linux in cloud computing, specifically in infrastructure as a service, platform as a service, and software as a service.

- Introduction to virtualization concept and Linux hypervisors, including Xen, KVM, and VirtualBox.

- Discussion about privacy and security when browsing the internet: topics include HTTP and HTTPS protocols, cookies, and private windows.

- Guidelines on password creation and selection, and best practices.

- Introduction to encryption methods.

In this lesson, you will learn:

- The lesson teaches about Linux shells, specifically the bash shell.

- Bash shell is not only a shell but also a scripting language, having its own syntax and vocabulary.

- Learners can experiment with simple commands and understand the syntax of the language.

- Although Linux has a powerful GUI, learning to work with the bash shell is essential for developers and system administrators.

- Bash shell is necessary for automating repetitive tasks, building, testing, and deploying software, accomplishing tasks quickly, working on servers without GUI, preparing for sysadmin or developer roles, performing advanced file management tasks, and accessing powerful tools only available from command line.

In this lesson, you will learn:

- Unix-like operating systems consist of two parts: the kernel, which does all the work, and the shell, which accepts commands to manage kernel activities.

- Linux permits choice of shell, with options including seashell, cornshell, zeshell, bornshell, and bash or the bornagain shell.

- Bash is pre-installed on most Linux distros and is commonly used.

- Users from a Unix background can install and use other shells; the command languages for the shells have similarities but are not identical.

- A terminal, to communicate with the shell, can be launched by searching for it via the desktop search feature or using keyboard shortcut Ctrl-Alt-T.

- It is suggested to add the terminal to favorites or taskbar for easy access.

- Once the terminal is launched, a command line prompt appears where things have specific meanings -- username, machine name, path of current directory in the form of a tilde symbol etc.

- The final symbol in the prompt, a dollar or pound sign, indicates that the shell is ready to accept commands; dollar sign is for ordinary users, while pound sign is for root or administrator users.

In this lesson, you will learn:

- The tutorial demonstrates a number of basic Linux commands.

- The 'hostname' command displays the name of the current working computer.

- The 'touch' command creates an empty file in the current working directory. For example, 'touch myfile' would create a file named 'myfile'.

- The 'ls' command lists all the files in the current directory. On most Linux versions, filenames are color-coded to indicate file type.

- The 'rm' command deletes a file permanently, unlike the graphical interface which moves deleted files to a recycle bin. Example: 'rm my file' to erase the earlier created file.

- The 'echo' command is used to display text on the terminal. For example, 'echo "hello, I am a Linux computer"' will display that text.

- The 'history' command lists previously executed commands. Commands can also be accessed by pressing the up arrow key.

- Commands can be reused or slightly altered by bringing them up from the history.

In this lesson, you will learn:

- Follow the exercise for practice with simple commands

- Create three files: test1, test2, test3

- List all the files in your directory to confirm creation

- Display the message: "I have created some files"

- Show command line history

- Remove two files: test1 and test2

- List all files in your directory to observe that test1 and test2 have been removed, and only test3 remains.

In this lesson, you will learn:

- Commands accept options which alter their behavior.

- Command line options can be short (single character with a minus sign) or long (more than one character with a double minus sign).

- Options are also known as switches.

- The 'ls' command lists files. Running 'ls' without options lists currently available files.

- The '-l' option for the 'ls' command (i.e., 'ls -l') displays files in a long format with more details (file type, permission, size).

- The '-a' option for the 'ls' command (i.e., 'ls -a') displays all files, including hidden ones (prefixed by a period).

- Same results can be achieved either by using short options or long options.

- To combine short options, type them immediately after a single minus sign without spaces (e.g., 'ls -la').

- Long options can be combined by prefixing each with a double minus sign and separating by spaces. 

- Some options require a specific value. For example, 'ls --format=single-column' lists in a single column format.

- Linux commands have built in help accessed by typing the command name followed by '--help'.

- Command arguments specify what the command works with. In 'touch my file', 'my file' is the argument.

- In 'ls /home', 'ls' lists a directory whose path is specified by the argument '/home'.

- In Linux, the root directory is known as forward slash ('/'). File and directory names are separated by forward slash when specifying a path.

In this lesson, you will learn:

- Bash, like other programming languages, allows for storing values in variables, which is useful for automating tasks in scripts.

- Variables don't need to be pre-defined and can be assigned values directly.

- Reference to a variable needs to be prefixed by a dollar sign ($). E.g., if variable "textval" is assigned a value "hello everyone", use "echo $textval" to display it.

- The variable defined is only valid in the current session and won't be visible in child processes.

- The "export" command converts a local variable to an environmental variable, which is visible in any child processes.

- Environmental variables are conventionally named in uppercase letters, but it's optional.

- One example is to create an environmental variable named "phone", assign the value "0756442105", then run "export phone". It can be shortened by setting the value while exporting the variable, e.g. "export phone=0756442105".

- Environment variables are inherited from the parent process when starting a terminal emulator, including "user" (current user's username), "path" (list of directories to search for commands), and "home" (location of the current user's home directory).

- To see the assigned environment variables and their values, "printenv" command can be used.

- Environment variables are only valid in the current session and won't be available in a secondly opened terminal.

- Bash and applications use configuration scripts to set up environment variables as needed.

In this lesson, you will learn:

- Certain characters possess special meanings in the Bash programming language and should not be used in file or variable names.

- Wildcards are useful when you wish to operate commands on several files with similar names. For example, an asterisk (*) represents any string of zero or more characters, a question mark (?) represents exactly one single character.

- Brackets can be used for a list of characters, where any enclosed character is considered a match.

- Braces are used for a range of characters; for example, a range from one to twelve can be written as 1..12.

- The 'ls' command is used to display any file or directory entries that begin with specific characters.

- If you use the question mark wildcard, it will show files followed by exactly one single character.

- In programming languages like Bash, a string of literal text is often needed. Bash expects these literals to be enclosed in either single or double quotes.

- There is a slight difference in usage between the two types of quotes: literals in single quotes appear exactly as entered, whereas in double quotes, special characters like backslash, backtick, and dollar sign retain their special meanings.

- The backslash character makes the character following it to be taken literally.

- By using the backtick special character, the text inside them is interpreted as a command and evaluated. The backslash character can cause the backticks to be interpreted literally when used inside of double quotes.

In this lesson, you will learn:

- Linux has two types of shell commands: internal and external.

- Internal commands are built into the shell and more commonly used.

- External commands are programs stored on disk, usually in the user bin directory.

- The system checks if a command is internal first, if not, it searches through directories stored in path until it finds an executable file with the command's name.

- If the path environment variable doesn't include user bin or the directory where the external command resides, the command won't work.

- The path variable can be modified to include new directories, thus allowing custom programs to behave as Linux external commands.

- Linux's type command can determine whether a command is internal, an alias, a function, or an executable file in the system's path.

- The which command locates a command or a program on the system by searching through the directories listed in the path environment variable.

In this lesson, you will learn:

- Learned the necessary background to work with Linux shell commands.

- Studied the terms shell and kernel in Linux.

- Identified bash as the most commonly used Linux shell with alternative shells available.

- Explored different parts of a command prompt.

- Studied simple, but useful commands like ls, touch, hostname, history, and echo.

- Learned syntax of bash commands and use of the --help option for specific commands.

- Gained knowledge on how to use variables in the Linux environment.

- Learned use of wildcards, quotes, and escaped characters and commands.

- Understood the difference between internal and external commands.

In this lesson, you will learn:

- The Linux command line interface (CLI) is often the primary way to interact with the system, especially on Linux servers.

- The CLI can be accessed through a terminal emulator even when using Linux as a desktop operating system with a graphical user interface (GUI).

- Using the CLI is often faster and more efficient than the GUI, making it beneficial to know how to use it even if the GUI is available.

- Seeking help directly from the Linux CLI fosters self-sufficiency, enabling users to solve problems without external resources. This is particularly useful when working alone or with limited/no internet access.

- Using the CLI to seek help can increase productivity as it may be quicker than switching to a web browser to search the internet.

- Built-in system help ensures guidance is directly applicable to the commands and versions installed on the system, preventing potential issues of irrelevant or incorrect external documentation.

- With hundreds of commands in even a minimal Linux installation, it's crucial to learn the built-in help systems. This will enable users to navigate and utilize the Linux CLI effectively. Available help resources include man pages, info pages, the /usr/share/doc directory, and commands themselves.

In this lesson, you will learn:

- "Man pages" in Linux are built-in help pages that provide detailed information about commands including their functions, available options, and examples.

- "Man pages" can be accessed offline and are the most common method for getting help on Linux due to their concise summaries of commands.

- "Info pages" offer more comprehensive documentation than "man pages", including hyperlinks for easy navigation, detailed information, tutorials, examples, and related topics. Despite these advantages, "info pages" are less popular than "man pages".

- The "/usr/share/doc" directory is a repository of documentation for installed Linux commands and packages. This directory contains varying documents, including change logs, release notes, guides, FAQs, copyright information, and more.

- Many Linux commands offer their own built-in help functionality, which can be accessed using the argument -h or --help. However, not all commands respond to these arguments, and in such cases, "man pages" or other sources of command information would be needed.

- Using a search engine to understand Linux commands can lead to confusion due to version discrepancies on different systems. Commands found online should not be used without understanding their functions to avoid potential harm to the system.

- Running unknown commands on a development or test system is advised before executing them on important systems, reducing the risk of error or data loss.

In this lesson, you will learn:

- Linux command line help can be found using 'man pages'. By typing 'man' followed by a specific command, detailed information about that command is displayed.

- In a man page, 'q' is used to quit and 'h' (uppercase or lowercase) stands for help.

- Five different commands can perform the exit action, with 'q' being the most straightforward.

- Within a man page, the arrow keys allow navigation line by line and the space bar moves down an entire screen.

- A forward search within a man page can be started by typing '/' followed by the search pattern. 'n' (lowercase) can be used to repeat the search and find the next match, while 'N' (uppercase) reverses the search direction.

- If help is needed with additional commands, type 'man' followed by the specific command (e.g. 'man LS' for help with the LS command).

- Remember to exit a man page by typing 'q'.

In this lesson, you will learn:

- The 'info' command provides detailed, interactive access to documentation.

- To view an info page, type 'info' followed by the command.

- To exit or quit from an 'info' page, type 'q'.

- Two ways to get help while in 'info':

  - By typing uppercase 'H' for a list of basic key bindings to navigate within the 'info' system.

  - By invoking the 'info' turotial by typing lowercase 'h'.

- Use up and down arrow keys to move up and down one line. Use page up and page down keys to scroll up and down one window.

- Typing lowercase 'l' closes the help window.

- The space bar can be used to advance one page.

- Underlined text in info pages signifies hyperlinks, which can be clicked to jump to a specific section of the documentation.

- To return to a previous section, type lowercase 'l'.

- To exit out of info pages, type 'q'.

In this lesson, you will learn:

- The /usr/share/doc directory is a repository of documentation for installed packages or commands on a system.

- This directory contains configuration details, change logs, readme files and more.

- Access this directory using the command 'cd /usr/share/doc'.

- Use the 'ls' command to list its contents.

- Each directory within /usr/share/doc typically corresponds to a specific package installed on your system.

- To look at documentation, navigate to the corresponding subdirectory, for example for 'sudo', navigate to the 'sudo' subdirectory.

- You can learn which directory you are in using the 'pwd' command.

- If a certain command's package isn't installed (e.g. sudo), the related subdirectory won't exist in /usr/share/doc.

- To view the contents of a file, use the 'ls' command followed by the file's name.

- The 'less' command is used for displaying file contents, with navigation similar to the 'man' command.

- To exit 'less', type 'q'.

In this lesson, you will learn:

- The final way to get help on the Linux command line is by combining a command with the --help or -h argument.

- This command shows the built-in documentation of the command including a brief summary on how to use it, a list of options and at times, examples.

- The mv command moves files.

- The pipe symbol (|) instructs Linux to use the output of one command as the input for another one.

- Not all commands respond to both --help and -h arguments. For instance, the mv command only responds to --help.

- The sudo --help command provides built in help for the sudo command which executes commands as other users, typically the root or super user.

- However, some commands, like iptable-save, don't accept --help or -h.

- --help and -h can be highly helpful for a quick overview of a command or to recall an option for a particular task, even though they might not always work.

In this lesson, you will learn:

- A web browser can be used to find help on a Linux command such as the curl man page.

- The information on a web page may be for a different version of the command than the one on your system— it might have new features or it could be outdated.

- It is possible to find the online man page for your specific Linux distribution.

- For example, searching "curl man page for Ubuntu" and clicking on the first link will bring up versions of Ubuntu— select the one likely using.

In this lesson, you will learn:

- The lesson taught how to get help with Linux.

- The methods covered include: using man pages, info pages, the /usr/share/doc directory, and the -h and --help options.

- These tools are used to find information on how to use commands on a Linux system.

In this lesson, you will learn:

- The find command helps locate files and directories using a supplied path and search expression.

- If you don't specify where or what to look for, find returns all files in the current directory and all its subdirectories.

- The '-name' option in the find command helps search files and directories using a particular pattern.

- The '-iname' option allows find to ignore case.

- The '-ls' option allows find to return a long format display of the files and directories found.

- The '-mtime' option allows find to search files based on the modification time.

- The '-size' option allows find to search files based on size.

- The '-newer' option allows find to find files and directories created later than a specified file.

- The '-exec' option allows find to execute a command against all the results it finds.

- An escaped semicolon ends the command you want to run using '-exec'.

- Running 'find' without specifying options, or using 'find .' yields similar results - finding everything in the current working directory.

- The locate command finds files and directories faster than the find command by using an updated index, but it doesn't provide real time results.

- Locate might not be installed by default on some systems.

- Consider using the locate command for quick file location searches, and the find command for more advanced searches or real-time results.

In this lesson, you will learn:

- The lesson covers the Linux file system structure and navigation.

- Learners will understand the organization of files and directories in Linux.

- The lesson teaches how to obtain detailed info on files and directories using Linux commands.

- Data and software management are crucial tasks for an administrator or developer.

- Knowledge on how to establish and maintain directory structures is essential for file and data organization.

- All Linux file system layouts have a similar structure.

- At the end of the lesson, learners will be capable of working effectively on any Linux distribution.

- The lesson includes useful tips and tricks for file management and efficient navigation of the directory structure.

In this lesson, you will learn:

- A file is a basic unit of data storage, which can be in various formats like text documents, databases, programs, spreadsheets, etc.

- A directory is used to organize files and other directories, often referred to as a folder.

- The terms 'directory' and 'folder' generally mean the same thing, but 'directory' is associated with command line interfaces, while 'folder' represents the same in graphical user interfaces.

- The content in a file is related and the data logically belongs together, such as a recipe.

- Directories can categorize files based on projects, subjects, or purposes, similar to categorizing chapters in a cookbook. For example, a "desserts" directory may contain files of different dessert recipes.

In this lesson, you will learn:

- Files can be created via several methods such as using a text editor to write and save a document, downloading content from the internet, using applications that save data, and executing specific commands in the terminal.

- An example of creating a new empty file is using the 'touch' command.

- To create a directory using the Linux command line interface, the 'mkdir' or 'make dir' command is used. For instance, typing 'mkdir my_new_dir' creates a directory named 'my_new_dir'.

- Verify that the directory has been created by running the 'ls' command, which lists files and directories in the current working directory.

- It is recommended to choose meaningful, easily understood names for files or directories, avoiding special characters like spaces, backslashes, or dollar signs as these can complicate Linux command line usage. Substitute a hyphen or underscore for these special characters if needed.

- File names can include a file extension at the end to specify the type of file. It follows the last period (or dot) in the name. For example, '.py' for Python programs and '.sh' for shell scripts.

- File extensions on Linux are used for human readability and to suggest how a file should be interpreted or used, but Linux does not depend on them to determine the file type or execution method. This contrasts with Windows where file extensions are used to determine application launch or file execution.

In this lesson, you will learn:

- Linux directories form a hierarchical structure, starting at the root directory.

- Each directory and subdirectory can contain files and/or more directories forming a tree structure.

- The tree structure can be visualized using the tree command in Linux. This command may need to be manually installed on some Linux distros.

- The tree command, when executed without arguments, shows the hierarchical structure of the file system layout with the current working directory as the start point.

- Linux represents the current working directory with a dot.

- The tree command can be used with the -F option to indentify file types. This appends a character at the end of each item to denote its type, like directories (/), executable files (*), symbolic links (@), socket files (=), FIFOs (|).

- The tree command can also be used with a path argument to get a hierarchical tree of any directory. Running the command with the root directory ("/") would provide a tree of the entire filesystem.

In this lesson, you will learn:

- The current working directory, present working directory, or working directory are used interchangeably to indicate the location within a directory hierarchy where work is currently ongoing.

- The initial working directory when a terminal opens or a remote server login occurs is the user's home directory.

- Home directories are typically found within the '/home' directory and share the same name as the associated username.

- The absolute path to the directory typically starts with a forward slash, representing the root of the file system.

- The tilde character ('~') represents the absolute path of the current user's home directory.

- The PWD ('print working directory') command can be used to check the location of the current working directory. This command gives the full directory path rather than using shortcuts such as the tilde symbol.

- Commands executed in a terminal work within the current working directory by default.

- Any path provided as a part of a command, which does not start with a forward slash, is interpreted as starting from the current working directory.

- If no path argument is provided, commands like 'ls' and 'tree' operate on the current working directory by default.

- Short relative paths can be used instead of full absolute paths to simplify the process.

- The 'cd' or 'change directory' command can be used to navigate to different parts of the file system hierarchy.

- Executing 'cd' without any arguments defaults the working directory to the user's home directory.

- 'cd' command followed by a path moves the working directory to the specified path.

- Upon executing 'ls', the output will display all the files and directories in the current directory.

- 'touch' command can be used to create a new file within the current working directory.

- The 'tree' command displays a hierarchical presentation of the files and directories originating from the current directory.

In this lesson, you will learn:

- Many commands in computer languages allow usage of a path as an argument.

- The 'cd' command is used to specify the path to the desired directory.

- Paths can be specified two ways: an absolute path and a relative path.

- Absolute path starts from the root of the file system and lists all directories you need to traverse to reach the specified file or directory.

- Relative path starts from the current directory and only specifies directories needed to find the file from the current location.

- Absolute paths are like specific addresses, leading to the exact location from any starting point.

- Relative paths are like directions from the current location to the destination; the results may change based on the starting point.

- In Linux, there are two special relative directories: dot (.) and double dot (..).

- Dot (.) points to the current directory and double dot (..) points to the immediate parent directory.

- The 'ls -a' command in Linux displays all files in a directory including hidden ones, which begin with a period.

In this lesson, you will learn:

- Using cd . does not change current directory.

- Dot dot (..) is used to navigate up the tree structure or refer to files in parent directory.

- Auto-completion or tab completion can be used to automatically complete names of directories when typing the cd command.

- Auto-completion will not work if there are multiple directories starting with the same letters; however, by pressing tab again, user can see list of directories starting with those letters.

- Users can further type to make their input unique, which allows auto-completion to work.

In this lesson, you will learn:

- All Linux systems, from powerful servers to tiny embedded systems, share the same file structure.

- The file system hierarchy is the same for most Unix systems.

- The 'tree' command can be used to view the topmost directories in a Linux system.

- The arrow symbol indicates a symbolic link, pointing to a different location in the file system.

- Key directories include /bin, which contains essential commands; /etc, storing system-wide configuration files; /home, containing user home directories; /tmp, for temporary files; and /var for variable data files like log files.

- This structure is known as the File Hierarchy Standard (FHS).

- The home directories in a Linux system are personal to the user, each user has their home directory under /home.

- Linux's permission structure safeguards individual data. Each user can manage their files in their home directory without other users accessing or altering data.

- Linux does offer a method for multiple users to collaborate on the same data set, which will be explored in a future lesson.

In this lesson, you will learn:

- The `ls -a` command in Linux lists all files and directories including hidden ones.

- Hidden files, recognizable by their initial period or dot, typically contain configuration settings.

- Examples include: .bash_history - stores commands executed by the user in a bash shell, .bash_logout - contains commands executed when logging out, .bashrc - holds bash configuration settings.

- The `ls -l` command (long list format) provides detailed information about files and directories, including file type, permissions, number of links, owner name, group name, file size, last modification time, and file name.

- Various options can be added onto the ls command, for example adding `-h`, `ls -lh` shows the file size in a human-readable format, showing kilobytes, megabytes, etc.

- Using `-d` with the ls command lists directories but not their contents.

- ls -d */ lists the directories in your current directory.

- The `ls -lt` command lists files in long format ordered by last modified time with the latest files at the start of the output.

- Adding `-r` to sorted lists reverses the order of the sort.

- The `ls -lS` command lists files in long format in order of size, showing the largest files first, useful for identifying disk space usage.

- Using `-X` with the ls command sorts entries by extension - useful for organizing files by file type.

- Files are sorted first by their extension, and then alphabetically within each extension group.

In this lesson, you will learn:

- Recursion is a process of performing a task repeatedly over smaller parts until completion.

- In Linux file system hierarchy, recursion involves applying a command to a directory, and then applying it to every subdirectory within.

- The command 'ls -R' views every file and directory within a specified directory, down to the deepest level. The '-R' stands for recursive.

- The output of 'ls -R' can be paginated for easier viewing by piping it to the 'more' command, for example 'ls -R | more'.

- Pressing the space bar while viewing paginated output displays the next screen, while typing 'q' quits the view.

- Other bash commands such as 'cp' (copy) can be used recursively. Adding '-R' copies a directory and all its contents into a new directory.

- The 'rm -R' command is used to recursively remove an entire directory structure, being careful as files are permanently deleted in Linux.

In this lesson, you will learn:

- Files in Linux are named collections of data, and directories keep related files together.

- Directories are arranged in a tree structure with a root directory at the top, and there can be many levels of directories beneath the root.

- The tree command is used to visualize this tree structure.

- There is always a single current or working directory when using the command prompt, which can be changed using the cd command.

- Either absolute or relative paths can be specified as arguments to a command. Absolute paths start from the root, while relative paths start from the current directory.

- The . and .. relative paths refer to the current directory and the parent directory respectively.

- Each user has a directory under the /home directory, named the same as the username, which is the current directory upon logging in. This can always be reached by typing the cd command.

- Unix-like distributions follow the fhs standard tree structure as defined by the Linux Foundation.

- Hidden files and directories, identifiable by a period at the start of their names, hold important scripts and configuration files, and can be viewed with the ls -a command.

- There are several command line options for the ls command.

- The -R option can be used with many bash commands to work recursively through a tree structure.

In this lesson, you will learn:

- The lesson covers managing files and directories.

- Topics include creating and modifying directory structures through moving, copying, and removing files and directories.

- The lesson teaches how to view file contents and introduces shortcuts to enhance efficiency at the command line.

- Discusses the benefits of computers' ability to store, retrieve, and process large volumes of data quickly.

- Highlights the value of managing data through command line due to its speed, ease, convenience, and automation capabilities, as opposed to a graphical user interface (GUI).

- The command line allows for automation of file management tasks, a feature that is not possible with GUIs.

- Future lessons will teach how to automate tasks by creating custom scripts.

In this lesson, you will learn:

- Files are named collections of related data.

- Linux file names are case sensitive, meaning a file named JanuarySales with a capital J is not the same as JanuarySales with a lowercase j.

- Each file has metadata such as its size, file type, and the last modification date.

- Metadata can be displayed using the 'ls -l' command in Linux.

- A directory is considered a special type of file in Unix and Linux systems.

- Directories, similar to folders in Windows, can contain files and other directories.

- All aspects of the operating system, including regular files, directories, devices, and processes, are treated as files in Unix and Linux - known as 'Everything is a file'.

- Directories are used to organize data and keep similar files together.

- In 'ls -l' output, the type of the file is indicated by the first character: a dash or hyphen for a normal file, and a D for a directory. Directories have many of the same attributes as files.

In this lesson, you will learn:

- Create a directory using the `mkdir` command followed by the directory name, e.g., `mkdir fd-demo`.

- Use `cd` command to change into the created directory, e.g., `cd fd-demo`.

- Create a directory structure that includes multiple subdirectories by using `mkdir` command. If it returns an error, it means the parent directories don't exist yet.

- Use the `-p` option with the `mkdir` command to create parent directories as needed. This option can be used even when the parent directories already exist - the command will simply ignore the existing directories.

- To view the contents of the created directories, use the `ls` command with `-R` option. This will return a recursive list of all directories and subdirectories.

- Another command to view directories is `tree`. It may not be installed by default on some Linux distributions.

- The `find` command can be used to list all files and directories in the current directory, or to find files or directories that match a specific name.

- Use the `-name` option with the `find` command to search for a file or a directory, e.g., `find -name Java`.

In this lesson, you will learn:

- In Linux, there is no command exclusively dedicated to file creation; this is similarly observed in other operating systems like Windows or Mac OS.

- The 'touch' command can create a new file or update the access and modification timestamps of an existing file without changing the file's content.

- A new file can be created using 'touch' by navigating to the relevant directory, typing 'touch' followed by the file name and hitting enter.

- Brace expansions or ranges can be used to create multiple files at once, following a pattern. For example, 'touch file{b..e}' will create files 'fileb' to 'filee'.

- The echo command, combined with redirection, can be used to create a file containing specified text. For example, 'echo hello > readme' creates a file named 'readme' containing the word 'hello'.

- To append text to an existing file, double redirection operator (>>) should be used in order to avoid overwriting existing file contents.

- Redirection feature works with any Linux command that produces output, not just the echo command.

In this lesson, you will learn:

- The `cat` command is used for displaying file content in the terminal and can combine multiple files into one.

- The `cat` command is mainly utilized for displaying content from a single file.

- `cat` command use with redirection involves entering file names to combine and a new file name to create.

- The `cat` command is helpful to combine daily log files into weekly or monthly ones for efficient pattern or issue searching.

- `cat` command is designed for text files; using it on a binary file results in unreadable output.

- If binary output affects the terminal, use the `reset` command to clear out any non-standard settings. If it does not work, reopen the terminal.

- For longer files where `cat` may not be useful, use pagers like `more` and `less` in Linux to control file output display.

- `more` and `less` display the first page of the file and allow users to scroll through the file line by line or page by page.

- `less` offers more functionality than `more`, including the ability to search backwards within a file.

- To view documentation for any command, use `more` or `less` followed by the directory path of the file.

- In `more` or `less`, you can press enter to view one more line of the file or the space bar for another page of the file.

- `less` has a help screen accessible by typing h, allowing users to learn more functionality. To exit help or the program, type q.

In this lesson, you will learn:

- The cp command in Linux is used for copying files and directories from one location to another.

- To create a copy of a file with a new name in the same directory, specify the original filename followed by the new file name as arguments.

- To view the contents of the new file and compare it to the original file, the cp command can be used.

- If the new file already exists, the copy would replace it. This requires careful action to avoid overwriting files to keep.

- The cp command includes options such as -n or -no-clobber that prevents copying if the target file exists already. -i provides a prompt before overwriting an existing file, and -u copies only if the target file does not exist or if it's older than the source file.

- To copy a file into another directory, the cp command should be followed by the source file name and the path to the target directory.

- To copy a file into another directory and rename it simultaneously, the cp command should be followed by the source file name and the path and new name of the file in the new directory.

- User can copy a directory with all its subdirectories and files to a different location by using the -r option in the cp command (which stands for recursive).

- This method allows users to replicate all the contents of one directory into a new directory.

In this lesson, you will learn:

- The 'mv' command is used to move or rename files and directories.

- The target file will be overwritten if it exists, similar to the 'cp' command.

- The same options of –i, –n, and –u can be used to protect against accidental overwrite.

- To rename a file or directory, the command requires the current name and the new name as arguments; e.g., mv file.txt newname4file.txt.

- To move a file to another directory, supply the source file path and the target directory path.

- Directories can be moved and renamed in the same method as files.

- Multiple files can be moved to a single directory by specifying them as source files with the destination directory included.

- Use of wildcards (like '*') allows for moving all files or specific type files in a batch.

- With many source files, the final argument should be the target directory.

- Moving multiple files or directories can be done in a single command statement.

- All these actions of moving and renaming files and directories can be verified using 'ls' or 'tree' command.

In this lesson, you will learn:

- The 'rm' command is used to delete files and directories.

- The 'rmdir' command is specifically designed to remove or delete empty directories.

- Attempting to delete a populated directory using the 'rmdir' command will result in an error message.

- The -r (or --recursive) option with the 'rm' command allows for the deletion of directories and their contents recursively.

- The -i (or --interactive) option prompts the user for confirmation before each removal. A combination of -ri or -ir can be used.

- The 'rm' command with no options will only remove files, not directories.

- The 'rmdir' command only removes empty directories; populated directories need to be emptied first for this command to work.

- The -p option with the 'rmdir' command removes a directory and any parent directories specified.

- Care should be taken when using 'rm -r' to ensure important data is not accidentally deleted. Using 'rm -ri' to ask for confirmation before each deletion can help mitigate such risks.

In this lesson, you will learn:

- Commands in Linux can be streamlined through the use of wildcards and pattern matching.

- Wildcards can be used to match and move multiple files at once using the 'mv' command.

- An asterisk (*) is used as a wildcard in commands to indicate any characters following a preceding identifier.

- Using wildcards and pattern matching in commands is referred to as 'globbing' in Linux.

- The functionality for globbing originated from a program named 'glob' developed in Unix in the 1970s.

- Pattern matching rules are guided by POSIX specifications which are foundational for Unix-like operating systems, including Linux.

- An example of this usage included separating different types of programming files (.java and .py) into respective directories.

- Different teams could then be assigned different files, with specific naming patterns used to identify which files to move to which team's directories.

- Pattern matching can include ranges specified using the first and last character of the range separated by a hyphen, as well as specifying multiple ranges within brackets.

- Character classes enclosed in double square brackets can be used to specify the type of characters you want to match, e.g. digit, alphanumeric, alpha, blank, lower, upper.

- The character pattern can be modified by using a not operator (represented by the caret symbol) to exclude specific matches.

- Pattern matching may vary slightly depending on the shell being used.

- Use of pattern matching can greatly increase efficiency when managing files.

In this lesson, you will learn:

- In a Linux environment, a file is a named collection of data, identifiable by attributes such as size and last modified date.

- A directory is a file type that groups similar files together, containing names and pointers to all its files.

- Linux commands for file and directory management include ls (list files in a directory), mkdir (create directories), tree, find, ls -R (view directory hierarchy).

- Filenames are case sensitive in Linux.

- The touch command and echo command with redirection can be used to create files.

- The contents of a file can be viewed using either cat, more or less commands.

- The cp command is used to make a copy of a file under a new name or another part of the directory hierarchy. The -r option allows the copying of an entire directory structure.

- The mv command moves or renames a file or directory within the directory hierarchy.

- To delete files and directories, use the rm, rmdir, and rm -r commands.

- The mkdir -p command allows creation of parent and child directories with a single command.

- Globbing, a form of pattern matching, can be used to handle multiple files with similar names. An asterisk matches any character number, a question mark matches exactly one character, brackets match listed characters.

In this lesson, you will learn:

- Archiving and compressing are essential for effective file management.

- Archiving consolidates files into a single, manageable entity, similar to packing books into a box.

- Compression decreases the size of the data, similar to reducing space taken by books by eliminating unnecessary pages and using smaller font.

- These methods make data transfer easier and faster while reducing the storage space needed.

- Archiving and compressing data can reduce costs associated with additional storage capacity.

- Improved data transfer speeds can expedite tasks like backups, restores, or data migrations.

- Compressed archival methods help comply with industry regulations that require data retention for certain periods.

- Archiving and compression make software distribution more efficient, reducing download time and data usage for users while lightening the load on servers and networks.

Archiving tools allow you to package multiple files, including entire directory structures,

into a single file.

This single archive file can then be unpacked to perfectly replicate the original archive

content, including all the files and directories.

You can use these archive files to copy data to a new location on the same system or even

on an entirely different one.

The most widely used archiving tool on Linux is the GNU version of tar.

The tar command, which is short for tape archive, was developed in the early days of Unix systems.

The purpose of the tar command was to create archives of files and directories for storage

of data, primarily on magnetic tape.

The archive files produced by tar were and still are commonly referred to as tar files

or tarballs.

As a quick aside, my first IT job was working at a large telephone company as a data center

technician.

I worked the night shift and clocked in at 11pm.

It was extremely rare that anything happened during the first hour of my shift.

But can you guess what happened at midnight?

That's right, all the backup jobs started to run.

I went from having my heels on the desk to running around the data center like crazy,

finding all the tapes that were being requested from all the servers.

I might be dating myself here, but this type of job still exists today.

Sure, the technologies have changed, the tapes look different, and the tape library systems

are more advanced, but they still require humans to operate.

Anyway, let's get back to the tar command.

Even though the tar command was designed to write to and read from tape drives, it could

also use other media as its target, including hard drives.

The tar command remained and still remains in use even after magnetic tape storage devices

fell out of favor.

Again, tape storage is still used today, but it's nowhere near as prominent as it once

was.

When using the tar command, you specify options to control the type of action tar performs,

such as archiving, extracting, or displaying content.

Unlike most other Linux commands, prefixing options with a hyphen or a dash is optional

when using tar.

This is because the earliest versions of tar did not require the hyphen.

However, the modern convention is to use a hyphen to specify options for a given command.

So tar allows for options to be specified with a hyphen to conform to modern conventions,

and it also allows for options to be specified without a hyphen to adhere to the earliest

uses of the command.

If this sounds a bit confusing, don't worry, I'll give you some examples in just a minute

to clear things up.

In this lesson, you will learn:

- Use the tar command to create a new archive. The c option instructs tar to create an archive, the v option can optionally be used to display each file as it's archived, and the f option directs tar to output the archive to the named file. (tar cvf /path/to/tarfile.tar /path/to/source)

- The archive file is created in the current working directory if no path is specified.

- Use .tar file extension as a best practice when creating tar files. This indicates that the file is a tar-created archive.

- Multiple files or directories can be named to be added to the archive, or entire directory structures can be archived using tar.

- Tar can also archive other tar files. For example, an archive file archive.tar could contain other archive files within it.

In this lesson, you will learn:

- Both relative and absolute file paths can be used when archiving files.

- Relative paths start from the current directory, while absolute paths start with a forward slash from the root of the file system.

- By default, 'tar' does not include the initial forward slash in absolute paths when storing files in the archive.

- The initial forward slash is removed to prevent accidental overwriting of existing files and to provide flexibility when extracting archive contents.

- If the absolute path is used to create a tarball, the leading forward slash is removed.

- If the content is extracted, a directory is created in the current working directory, not in the exact absolute location.

- To force files to be extracted using the exact absolute path, you can either change to the root directory before extraction or use the '-P' option during the creation of the archive. This preserves the initial forward slash.

- It is recommended to only use the '-P' option if necessary as it is not the default setting for tar.

- An example command to force tar to preserve the full absolute path is: tar -cvPf [filename].tar [file_to_archive].

In this lesson, you will learn:

- To display contents of an archive with the tar command, use the t option. t can be thought of as "table of contents".

- Optionally use the v option to display detailed info on files and directories in the archive, including permissions and ownership.

- Specify f option to tell tar to use the first argument as the archive file to examine.

- It's generally assumed user wants to see entire content of an archive, but a specific part can be viewed by supplying existing path in the archive.

- The tar command doesn't traditionally use dashes or hyphens for arguments, though it's still possible. Using tar with or without a hyphen for options yields the same result.

In this lesson, you will learn:

- The x option in tar extracts the contents of an archive.

- The v option displays the name of each file as it's extracted.

- The f option uses the first argument as the archive to extract from.

- Existing files with matching name and locations will be overwritten when you extract from an archive.

- Tar uses the file paths stored in the archive to locate where to place files.

- Unless the -P option is used, these paths will be relative, meaning the files will extract into your current directory.

- If -P option is used, files extracts into the root directory.

- While extracting, ensure you're in the correct directory.

- You can utilize the command 'tree' to check existing files under current directory.

- A partial extraction from the tar ball can be performed.

- Original directory structures are created under the current directory after extraction.

- Wildcards can be used to extract certain files only by using the --wildcards option.

- The --wildcards option goes after the name of the tar ball during extraction.

- Prior existing directories are not recreated during extraction.

In this lesson, you will learn:

- Compression is used to reduce bandwidth for file transfers and disk space for storage.

- Daily use files are usually not compressed as it renders them unusable for most applications.

- Image files like JPEGs are an exception, as they are often compressed and handled well by image processing software.

- There are two types of compression: lossless and lossy.

- Lossless compression retains original data, making it ideal for applications requiring preservation of exact original data.

- Lossy compression, which allows some data loss upon compression and decompression, is appropriate where minor data loss is acceptable like in JPEG images and MP4 videos.

- Data compression utilizes various methods such as replacing long strings of identical characters or frequently used character strings with a shorter version.

- Compression ratio measures the efficiency of a compression algorithm by comparing the original and reduced file sizes.

- Factors such as the compression algorithm, type of data, and the compression level requested can influence the compression ratio.

- High levels of compression make smaller files, but require more time, memory, and CPU resources.

- A trade-off between compression level and computational resources is needed when deciding on a compression strategy.

In this lesson, you will learn:

- Compression tools commonly used on Linux are xz, gzip2, and gzip. They create lossless compressed files.

- xz provides the best compression ratio. However, it may be slow for large files. Its decompression tool is unxz, and files are saved with an .xz extension.

- Bzip2 is quicker than xz but does not compress as efficiently. bunzip2 is the decompression tool for bz2 files.

- Gzip is the fastest compression tool but has a less effective compression ratio. The decompression tool is gunzip, and files are saved with a .gz extension.

- The time taken to create an archive and compression ratio can be based on the type and size of the data.

- File decompression must be done using the tool that compressed it.

- The file extension indicates the tool to use for decompression.

- Compression tools have utilities for viewing the contents of the compressed files.

- Upon file compression, the original file is removed, and the name is retained but with the added relevant extension.

- Decompression tools rename the decompressed file back to the original, and the compressed file is removed.

- The compression level can be altered using options 01 through -9, with -9 indicating the highest compression level.

In this lesson, you will learn:

- The tar command can be used to compress the resulting tarball, allowing for archiving and compressing data with a single command.

- Using the standard naming convention for the file extension of the compressed tarball is recommended for clarity.

- Different options can be utilized for varying compression methods: j for bzip2, J for xz, and z for gzip.

In this lesson, you will learn:

- Sharing data between Linux and Windows requires use of Windows compatible utilities to create archives.

- Many Windows users lack the software to extract from Linux-based tarballs or compressed files.

- Most Linux distributions include zip and unzip utilities for creating and extracting from Windows-compatible zip files.

- If these utilities are not installed, they can be added from your Linux distribution's repository.

- When archiving entire directories, use the -R option with the zip utility, otherwise the contents of the directory will not be included.

- Compression is incorporated in these utilities like their Windows counterparts, eliminating the need to archive and compress files separately.

In this lesson, you will learn:

- Learned how to archive and compress files.

- Main reasons for archiving and compressing are reducing storage usage, increasing data transfer speeds, and compliance with legal requirements.

- Got acquainted with Linux tools for archiving and compressing files: GNU tar (standard tool), xz, bzip2, gzip.

- Explored methods to restore compressed files to their original form without data loss using unxz, bunzip2, gunzip.

- Learned how to combine tar with xz, bzip2, or gzip to archive and compress files using a single command.

- Learned how to use zip and unzip for creating and extracting from a Windows-formatted zip file.

In this lesson, you will learn:

- The lesson teaches methods to view, search, and modify file contents.

- Learners will understand how to chain or combine commands using pipes.

- The lesson covers techniques for redirecting the input and output of commands.

- The educational content includes advanced search functionality using complex pattern matching techniques.

- These skills are not only certification requirements but are also applicable in daily tasks in a Linux environment.

- The gained knowledge can be utilized to manage system logs, automate tasks, solve problems and manipulate data on Linux systems.

In this lesson, you will learn:

- You can use commands 'head' and 'tail' to view the contents of files.

- The 'head' command is used to inspect the beginning or top part of a file, while the 'tail' command is used for the end part.

- These commands are beneficial when checking the first or last few lines of large files such as log or configuration files, without needing to scroll through the entire file.

- By default, 'head' displays the first 10 lines, and 'tail' shows the last 10 lines of a file.

- To view a different number of lines, use the '-n' option followed by the desired number. For example, 'head -n 20' will show the first 20 lines.

- The 'tail' command is useful for viewing most recent log entries without viewing the complete file.

In this lesson, you will learn:

- The WC command shows the number of lines, words, and bytes in a file.

- The WC command can be modified to show only specific data: use -L for line count, -W for word count, and -C for byte count.

- To specify a file, use WC followed by the option and the file name.

- Originally, the -C option stood for character count, with each character equal to one byte.

- However, modern use of multibyte character encodings, like UTF-8, alters the meaning of -C, which now counts the total bytes as characters can consist of multiple bytes.

- As an example, the file etc-passwd contains 56 lines, 98 words, and 3272 bytes; to view just the line count, use wc -L etc-passwd.

- Each line in the etc password file signifies one user account, so 56 lines mean 56 user accounts.

In this lesson, you will learn:

- The sort command in Linux is used to arrange lines of text from a file in a specific order.

- By default, it sorts data alphabetically starting from the first character of each line.

- It can be adjusted to sort the data numerically, which orders the entries based on their numerical value.

- The sort command can be directed to perform the sorting operations on specific fields or columns.

- Some common options for the sort command include:

    - '-n' to sort numerically

    - '-r' to reverse the order of sorting

    - '-k' to specify a sort field

    - '-o' to specify the output file

    - '-t' to set the field separator.

- A directory named 'Searching' was created to work on a file named 'Names.'

- The sort command uses the whole line as the sort key by default, but the key can be adjusted using the '-k' option.

- A line of text is seen as a collection of fields separated by whitespace, with each field numbered from left to right starting from one.

- The '-k 3' sort command is used to sort by the third field.

- To reverse the sorting, use '-r.'

- More information about the sort command can be found in the Linux command manual (man page).

In this lesson, you will learn:

- The cut command extracts specific sections of text from each line in a file.

- Allows selection and display of parts of each line based on specified options.

- Useful for isolating columns of data in a file or characters from each line.

- The dash C option displays the first character of each line in a file, specified by character number.

- The dash F option extracts certain fields; more convenient than specifying character numbers due to varying field lengths.

- Cut command defaults to using the tab character as the delimiter.

- The dash D option specifies a different delimiter to the cut command.

- Delimiter character is specified immediately after the dash D option.

- To specify multiple fields for extraction, list field numbers separated by commas.

- Example usage: for extracting the third field (names) and fifth field (phone numbers) from a file, use 'cut -f 3,5 -d " "' command.

In this lesson, you will learn:

- The 'tr' command stands for 'translate' and is used for replacing or deleting text.

- It differs from other commands by not taking a file name as an argument but reading from standard input, usually supplied by keyboard typing or input redirection from a file or another command.

- The format of the command is tr, followed by a source set, then a target set.

- To replace specific characters, such as lowercase 'a', capital 'A', and the '@' sign, with '4', the command is run as 'tr "aA@" "4"'.

- The tr command can convert lowercase letters to uppercase and vice versa by specifying character classes ('lower' and 'upper').

- The tr command can also translate sequences of identical characters into a single character, known as squeezing, using the '-s' option.

- The tr command can be used to replace spaces with commas to prepare data for a CSV file.

- The command requires input text to be typed in, and 'control + d' terminates the input.

- Examples given include changing spaces to commas, converting lowercase letters to uppercase, and squeezing spaces in a text.

- Usually, the tr command is used with data in existing files, not typed directly into the command.

In this lesson, you will learn:

- The grep command is a tool used to find and display text or patterns within files in Linux.

- grep can be used in a number of situations, such as finding specific text in unknown files, locating all modules within a program that reference an updated method, or verifying if a large, potentially unnecessary file is still being used by scripts.

- The format of the grep command is "grep", followed by the pattern to search for, and the file(s) to search within.

- Common options to use with grep include: -i for case insensitive searches, -r to recursively search all files in a directory hierarchy, -c to return a count of matches found, and -v to return lines that do not contain the search text.

- The grep command is demonstrated by making copies of two files and then using grep to search for a username in all files in the current directory.

- The command returns a line for each file containing the searched text, with the file path, followed by a colon, followed by the line that contains the text.

- If only searching through one file, the file name will be omitted.

- Adding the -c option to grep returns a list of all the files with a count of how many matches were found in each.

In this lesson, you will learn:

- The course will expand upon prior knowledge of output redirection to include input direction and error message redirection.

- Learners will gain deeper understanding on the application of redirection in input, output, and errors.

- The course will teach the use of input redirection to provide data to a command from a file.

- It will also instruct on using pipes to send output from one command to another.

- Separate handling of error messages from the regular output of a command will also be covered.

- By the course's end, learners will have a comprehensive understanding of managing command input and output on Linux.

In this lesson, you will learn:

- Linux has three default input and output types also known as streams or channels: standard input, standard output, and standard error.

- By default, standard input comes from the keyboard and standard output and standard error are displayed on the screen.

- Each type of input and output has a file descriptor; numerical representations of open files. Standard input is 0, standard output is 1, and standard error is 2.

- In Linux, almost everything is represented as a file.

- Output from one command can be used as input for another or redirected to a file using greater than (>): this will overwrite an existing file or create a new one.

- To append output to an existing file without overwriting, use double greater than signs (>>). This will also create a new file if it doesn't exist.

- Input from a file to command can be redirected using a less than sign (<).

- The signs '>' and '>>' are shortcuts for '1>' and '1>>' respectively, with '1' being the file descriptor for standard output. Similarly, '<' is a shortcut for '0<' where '0' is the file descriptor for standard input.

- An example of using these processes is extracting all commands except 'LS' from a .bash_history file and writing them to a commands.txt file. First use grep -v (to find lines not matching given criteria), then use the cut command to extract the first field (the command), and finally write the result to commands.txt.

In this lesson, you will learn:

- Error messages from a Linux command are sent to standard error, represented by file descriptor 2.

- By default, standard error is displayed on the screen.

- The 'greater than' symbol together with the number 2 is used to redirect standard error.

- Two reasons for redirecting error messages are: maintaining separate logs of error and standard output messages, and preventing error display when running commands.

- An example of error message redirection is the 'find' command which searches for a file in the file system and redirects any errors to a specified text file.

- As a normal non-root user, the 'find' command generates error messages for inaccessible files or directories.

- There must not be a space between the file descriptor number and the redirection operator.

- A space is optional between the redirection operator and its destination.

- Two accurately formatted commands are provided on the screen.

In this lesson, you will learn:

- The null device, also known as the bit bucket, discards whatever data is sent to it.

- You can redirect output to the null device to ignore it.

- Redirection is useful in ignoring error messages from commands or saving them to a file instead of displaying on screen.

- An example command to ignore errors is: 'find command > /dev/null'.

- The 'ls' command can be used to list a file; if the file doesn't exist, the error can be saved in a log file.

- A double greater than symbol (>>) is used to append data to a file rather than overwriting it.

- Using the null device can declutter the screen, for example when searching several files with 'grep', by redirecting error messages to dev null. This makes the output easier to read.

In this lesson, you will learn:

- Redirect stdout using > or >>

- Redirect stderr using 2> or 2>>

- Redirect both stdout and stderr using &> or &>>

- To capture both standard output and standard error, use "2>&1".

- To redirect standard error to standard output, use '2>&1', this combines standard error and output.

- With redirection, a file typically follows the redirection operator: >/tmp/out.txt

- From bash 4.0, a new syntax was introduced: '&>' is a shortcut for '2>&1'.

In this lesson, you will learn:

- Many Linux commands accept standard input, which by default comes from the keyboard.

- You can use the contents of a file as standard input to a command using the less than symbol.

- To do this, run the command followed by the less than symbol and the name of the file you want to use as input.

- The example given uses the contents of the file as the standard input for a command that translates all lowercase letters to uppercase.

- By default, the command result is displayed on the screen as standard output.

- The "tr" command can also be used with redirection to replace spaces in a file with commas and redirect output to a new file.

- To achieve this, use "tr", followed by the symbol for space in quotes, then a comma in quotes. The input file and the output file are then specified.

- The "names" file input for this example was transformed with spaces replaced by commas.

In this lesson, you will learn:

- Here documents in Linux allow for redirection of multiple lines of input to a command without needing separate text files.

- Particularly beneficial in scripting, Here documents allow embedding of text blocks within scripts.

- A Here document uses the double less than operator as an input redirection method and a chosen delimiter to indicate the end of the text block.

- The syntax for a Here document involves a command, followed by two less than symbols without spaces, then a delimiter, the input text, and the delimiter repeated.

- The delimiter, a string of characters marking the end of the input block, is usually EOF (End of File), END, or any unique string absent from the input text.

- The input text refers to lines of text passed to the command as standard input.

- Here documents can be utilized with any Linux command that can take input, like the cat command, commonly used to concatenate and display file content.

- Here documents can be used to create files with multiple lines of text, useful for creating configuration files or scripts within another script.

- Key points about Here documents are that they use the double less than operator, the text block continues until the delimiter appears alone on a line with no leading or trailing spaces or tabs, and they are helpful for scripting and embedding multiple lines of text without using external files.

In this lesson, you will learn:

- To use the functionality of two commands together, one can connect the output of one command to the input of another, known as a pipe, indicated by the vertical bar symbol.

- By piping the output of the 'ls' command (which lists files in a directory) to the 'more' command, a long list of files can be viewed a screen at a time.

- There is no limit to the number of commands that can be piped together.

- If you want a list of files and their sizes placed into a file, you can use a sequence of three commands 'ls' (list files), 'tr' (squeeze out spaces), and 'cut' (extract specific fields).

- The output of the 'ls' command is piped to the 'tr' command with '-s' flag for squeezing out spaces, followed by the 'cut' command to extract fields like the file size and file name.

- The sequence of the three commands ends with a redirection operator '>' to save this output into a file.

- Piping commands along with redirection allows for great flexibility in the Linux operating system.

In this lesson, you will learn:

- The grep command in Linux is empowered by using regular expressions to define precise searches.

- The term grep is an abbreviation of 'global regular expression print'.

- Regular expressions (regex) are similar to wildcard matching but symbols may have different meanings within regular expressions.

- Extended regular expressions (EREs) provide additional functionality. To use EREs with Linux commands like grep, include the -E option.

- Characters used in regular expressions may have other meanings in bash and hence it's recommended to enclose regular expressions in quotes.

- Regular expressions allow the user to specify a sequence of characters to match a defined pattern.

- Metacharacters are included in the pattern to convey special meaning.

  - The period metacharacter ('.') matches any single character except newline.

  - The asterisk ('*') is a multiplier indicating zero or more of the preceding character appears at the defined position.

  - The plus character ('+') is a multiplier indicating one or more of the preceding character should appear at the defined position.

  - The question mark ('?') indicates zero or one occurrences of the previous character at the defined position.

  - Square brackets ('[]') enclose one or more characters that must be searched for at a given position.

  - The caret symbol ('^') inside square brackets acts as a not operator, outside square brackets it indicates the start of a line.

  - The dollar sign ('$') matches the end of a line.

  - The pipe symbol ('|') specifies two alternatives to search for and requires usage of the -E option.

- The order of the patterns is important in regular expressions.

In this lesson, you will learn:

- Learned several Linux commands for managing file contents.

- Gained skills in using redirection and pipes in command lines.

- Learned advanced searches with grep command using regular expressions.

- Learned how to view the beginning of a file using the head command.

- Learned how to view the end of a file using the tail command. 

- Learned to organize file contents with the sort command.

- Learned to count the number of characters, words, and lines in a file using the wc command.

- Learned to extract specific sections of a file using the cut command.

- Learned to perform substitutions or translations on line contents with the tr command.

- Learned about grep command for searching file contents.

- Learned redirecting of standard output using a single or double greater than sign.

- Learned redirecting of standard error using two greater than signs.

- Learned to combine standard output and standard error using ampersand greater than symbol.

- Learned how to redirect standard input from either a file or a here document.

- Discovered how to join the output of one command to another's input using the pipe symbol.

- Learned how to use regular expressions with a grep command.

In this lesson, you will discover what you will learn over the next few lessons, including:

- Learning how to use Bash as a programming language.

- How to consolidate bash commands into a script which can operate as a single Linux command.

- Making scripts versatile is possible by including variables, user arguments, conditionals, loops, and exit statuses.

- Linux's big advantage is its capacity to automate repetitive tasks.

- Putting often run series of Linux commands into a single file, or script, allows for more efficient reuse.

- Scripts can execute tasks similar to other commands.

- Scripting is useful in different scenarios such as installing apps, scheduled backups, and setting up standard dev environments for new team members.

- Scripting ensures more consistency, saves time, and minimizes the risk of errors.

In this lesson you will learn:

- A script is a series of Linux commands stored in a file.

- Scripts can range from very simple, containing just one command, to highly complex containing multiple commands and logic.

- A script is similar to any other Linux command, and it can be executed by typing its name at the command prompt.

- Scripts can be created any text editor.

In this lesson you will learn:

- Vi and Vim are powerful text editors

- Vim stands for "vi improved"

- Vim is often installed by default as an enhanced version of vi on most modern Linux distributions

- In Linux, both vi and vim refer to the Vim editor

- Vim operates in three distinct modes: normal mode, insert mode, and command mode

- Normal Mode allows you to navigate and input instructions for editing

- Insert Mode allows you to directly type text into the document

- Command Mode allows for commands such as saving the document or quitting the editor

- To open a file for editing with vim, run vim followed by the file name or vi followed by the file name

- If the opened file does not exist, it will be created. If it exists, its contents are ready to be edited

- Pressing escape will return to Normal Mode

- The "i" command activates Insert Mode

- In Insert Mode, typed text is added to the document

- Normal Mode allows for various commands starting from cursor position; 'i' inserts characters, 'A' appends at the end of the line, 'x' deletes a character, 'dd' deletes a line, 'u' undoes a change, 'r' replaces characters, 'yy' copies the current line, and 'p' pastes the copied text.

- Commands can be prefixed by a number to repeat the instruction that number of times

- Command Mode allows the saving (:w) and quitting (:q) of the document; ':wq' does both i.e., saves and quits

In this lesson, you will learn:

- The nano editor is a lightweight and simple text editing tool.

- The editor supports basic commands even though some users prefer Vi or Vim for more features.

- To edit a file with nano, use the command 'nano' followed by the file name path.

- If the requested file does not exist, the nano command creates a new file. If it already exists, its contents are ready for editing.

- Nano uses two areas on the screen: the top for editing and the bottom section for commands.

- The editing area allows users to add and alter content in the file using normal editing and navigation keys such as arrow keys, the delete key, and the backspace key.

- The caret symbol represents the control key in the commands displayed at the bottom screen.

- To exit nano, you need to hold down the control key and then press X.

- Files are saved in nano by typing control O. The term employed to denote saving is 'write out'.

- On saving, users are prompted for a file name. If the original name is to be kept, just press enter. For changing the name, erase with backspace, type a new name, and then press enter.

- Whenever a file gets saved, a notification appears indicating how many lines were saved.

- After editing and saving, to exit nano and return to the prompt type control X.

- If changes are made and control X is pressed before saving, nano prompts to save the changes.

- Users can opt to either save changes with control O and then exit with control X or they can make edits and then type control X which will prompt them to save changes before exiting. The choice of procedure is subjective to the user's comfort.

In this lesson, you will learn:

- A script in Linux is a text file containing one or more commands.

- To run the script, the file name is entered in the command line.

- The script text file needs certain conditions:

  - It needs to be executable, meaning it has execute permissions.

  - It should reside in a directory included in your path environment variable.

- Bash (the shell) only runs scripts located in directories included in the path environment variable.

- If the script isn't in one of the path directories, its location must be explicitly specified or the command must be prefixed with "./"

- Creating files typically don't have execute permissions by default leading to a "permission denied" error, but this can be fixed by adding execute permissions.

- It's common practice to create a dedicated directory for scripts and permanently add it to your path.

- To have environment modifications such as path applied automatically during terminal startup, modify the hidden .bashrc file in your home directory.

- In Linux, every file has read, write, and execute permissions. These can be set for the file's owner, users in the file's group, and all other users.

- If execute permission isn't enabled, use command "chmod +x" followed by filename to make the file executable.

- If the script has syntax errors, use the "cat -n" command to highlight where the problem lies.

In this lesson, you will learn:

- To follow shell scripting conventions.

- Avoid special characters such as spaces in script names as they can complicate execution; use underscores, hyphens, or dashes instead.

- Script names should be meaningful, indicating the purpose of the script.

- It's common practice to give scripts a '.sh' file extension to ensure others quickly identify that it's a shell script.

- The first line of a script, or 'shebang', dictates which interpreter to use when executing the script.

- An interpreter reads and executes code in a programming or scripting language directly without prior compilation.

- The shebang for a bash script is '#!/usr/bin/bash', assuming the path to bash is '/usr/bin/bash'.

- Specifying the interpreter in the shebang line guarantees that the script runs consistently, regardless of how it's executed or which shell the user is running.

- Without a shebang, a script's contents will be interpreted by the current shell, leading to possible unpredictable behavior, based on variations between different shells.

- Including a shebang in your scripts leads to more predictability and portability by clearly defining the exact interpreter to use.

- To find the path to the interpreter, one can use the 'which' command. For instance, 'which bash' returns '/usr/bin/bash'.

- '/bin/bash' and '/usr/bin/env bash' are other viable options for shebang lines.

- Comments within scripts are text ignored by the interpreter, providing valuable context for humans reading the script. Comments help explain the script purpose and logic.

- A hash symbol '#' introduces comments, either for the whole line or after a command in the same line. Comments should make the script easy to understand.

In this lesson, you will learn:

- Environment variables can be accessed in scripts, but any changes made within the script only persistent during the execution of the script due to the script being run in a subshell, a child process of the parent shell.

- Changes made to environment variables by a script are not carried through to the parent process.

- To check the value of a set variable, use the echo command.

- Scripts can also be forced to run in the current shell. (Sourcing)

- Local variables can be used to store information within a script.

- Local variables do not require exporting unless needed by child processes. Their names can contain letters, numbers, and underscores, but cannot start with a number.

- When assigning a text string to a variable, it's advisable to enclose the value in quotes to prevent potential errors created by special characters.

- Bash variables are always treated as text strings. Common methods of value assignment include literal strings, other variables' contents or the output of commands using command substitution syntax.

- Command substitution allows output of a command to be reused throughout the script without needing to re-execute the command.

- Variables can be assigned via literal strings, using the content of another variable, or by assigning the output of a command.

- The output from different techniques for assigning variables can be mixed in one new variable, allowing versatility in the type of content variables can hold.

In this lesson, you will learn:

- Linux commands use arguments to provide specific information to a command.

- Arguments can be integrated into user-written scripts, enhancing their flexibility and adaptability.

- In scripts, arguments act like variables, with the first user-given argument accessed as $1, the second as $2, and so forth, up to $9. For more than nine arguments, they can be referenced using braces such as ${10}, ${11}, etc.

- Special arguments include $0, which holds the script's path, and $#, which contains the number of arguments provided by the user.

In this lesson, you will learn:

- Conditions in scripts help make scripts flexible by allowing different actions to be executed depending on the circumstances.

- Conditions can include comparisons of strings or numbers, checking for a file's existence, among others.

In this lesson, you will learn:

- String comparisons in scripts help make decisions based on text input.

- Common comparison operators include: == (checks if two strings are identical), != (checks if two strings differ), -z (checks if a string is empty), -n (checks if a string is not empty).

- Bash scripts also allow comparisons on numeric values using operators such as: -eq (equal), -ne (not equal), -lt (less than), -le (less or equal to), -gt (greater than), and -ge (greater than or equal to).

- Variables can be accessed by using a dollar sign followed by the variable name (e.g., $variable), or by enclosing the variable name in braces after the dollar sign (e.g., ${variable}), which helps clarify the variable’s boundaries when other characters are adjacent.

In this lesson, you will learn:

- In Linux, the termination of programs and scripts results in an exit status or code, also known as a return value.

- An exit status of 0 signifies successful execution of a command, while a non-zero exit status usually indicates an error occurrence.

- Occasionally, non-zero exit codes can represent specific types of success, but typically they indicate errors.

- The exit status of the last executed command is stored in a variable denoted by "$?".

- You can find the meaning of an exit status by referring to the manual page for the command returning the exit status.

- For scripting best practices, use the exit command followed by a numeric code as an argument for specific occurrences or statuses.

- Upon encountering the exit command in a script, the script stops and no further commands are executed.

In this lesson, you will learn:

- A for loop is used to repeat a command or series of commands for each item in a list.

- The list can include a series of strings, or a variable containing a list can be provided to the for loop.

In this lesson, you will learn:

- Bash can be used as a programming language by creating scripts, which are files containing a series of Linux commands.

- Scripts can be created and edited using text editors such as nano, vi, and vim.

- Scripts start with a shebang to specify which interpreter executes the commands.

- Multiple Linux commands can be combined into one script for single-command execution.

- Using the chmod command can make scripts executable.

- Shell scripts should follow file naming conventions, such as using .sh as the file extension and avoiding special characters in file names.

- Adding comments to a script improves its understanding.

- Scripts can employ the use of variables.

- Scripts can accept and use arguments.

- Conditional statements help control the flow of scripts, facilitating comparisons of strings and numbers.

- Exit statuses can be viewed with the $? variable.

- For loops can be used in shell scripts to iterate over a list.

In this lesson, you will learn:

- There are many options available when selecting an operating system (OS), including numerous Linux distributions designed for specific use cases.

- The choice of OS is crucial in an IT professional's work as it can greatly influence project outcomes, affecting productivity, security, compatibility, and user experience.

- An OS is a software system that manages resources and services for applications, controls and allocates hardware resources and uses device drivers to interact with hardware.

- Applications access hardware resources through requests to the OS using system calls.

- An OS generally includes a command line interface and may also provide a desktop graphical user interface (GUI) and additional software such as text editors.

- On Unix and Linux systems, one can use the 'uname' command to obtain information about the OS, such as the kernel version, kernel name, and kernel release information.

In this lesson, you’ll explore key factors to consider when choosing an operating system for your projects. We’ll cover compatibility with hardware and software, balancing stability with access to the latest technology, cost considerations, and the support options available. You’ll also learn how to assess internal capabilities, performance needs, security requirements, ease of use for non-technical staff, and future-proofing to ensure long-term viability. By the end of this lesson, you’ll be equipped to make informed decisions when selecting the ideal OS for your specific use case.

This lesson covers the major categories of operating systems, including Linux, Unix, macOS, Windows, and mobile OS like iOS and Android. You'll learn about the strengths and target markets of each system. Linux dominates servers due to its performance and flexibility, while Unix, with its roots in high-performance servers, shares similarities with Linux. macOS is exclusive to Apple hardware and features a user-friendly interface built on a Unix-based kernel. Windows, a proprietary OS, is prevalent on desktops and offers strong compatibility. Finally, mobile OS like iOS and Android are discussed, with Android using a modified Linux kernel.

In this lesson, you'll learn about Linux distributions, or "distros," which include the Linux kernel and software that form a complete operating system. Popular distros include Debian, Red Hat, Fedora, Ubuntu, and Linux Mint. The lesson also covers the lifecycle of a distro, from alpha and beta testing phases to stable releases, which are suitable for production environments. You'll understand the differences between long-term support (LTS) and interim releases, as well as how to choose the right distro for your needs based on support lifecycles and stability.

This lesson describes the different types of Linux distributions:

1. Enterprise Class Distributions: Prioritizes stability, security, and excellent support. Suitable for larger businesses due to their robustness and service supports. Examples include Red Hat Enterprise Linux, SUSE and Ubuntu LTS.

2. Consumer Distributions: Target home users and small businesses. Supports the latest hardware and features, prioritizing modernity over stability. Ideal for users interested in experimenting with new tech or gaming. Examples include Ubuntu, Fedora, and Linux Mint.

3. Experimental/Hacker Distributions: Updates are frequent and continuous. Ideal for developers who want the latest hardware and software. Offers high customization. The risk includes potential bugs due to constant updates. Examples include Arch Linux and Gentoo.

4. Linux as a Server Operating System: Highly reliable and efficient, typically managed remotely via the command line. Popular among servers due to its resource efficiency compared to GUI-based servers.

5. Linux on Desktop: Has smaller market share due to vendor lock-in and the frequent pre-installation of other systems on hardware. While facing challenges, Linux is appealing for SMEs and home users due to the availability of high-quality, free, open-source software, making it a budget-friendly alternative.

6. Linux in IoT: Linux is often used in embedded devices such as robots and controllers due to its minimal overhead, ideal for limited resources of IoT devices. Linux's flexibility makes it perfect for efficient operation and management of IoT devices.

By taking the lesson, users can gain knowledge on which Linux distribution suits their needs best and understand the various applications of Linux.

In this lesson, you'll gain an understanding of major operating systems including Linux, Unix, macOS, and Windows, along with the factors that influence their selection such as cost, reliability, security, and application compatibility. The lesson also dives into the variety of Linux distributions available, providing a guide for choosing a distro based on its lifespan, stability, technological edge, and system purpose, whether it's for server, desktop, or embedded systems. This knowledge will enable you to make informed decisions when selecting an operating system.

This lesson provides a comprehensive guide on computer hardware and its impact on cost, performance, and use-case suitability. Even though the specifics of hardware constantly evolve, the fundamental concepts remain the same and will still be applicable in the future. The knowledge gained from this lesson will be beneficial when purchasing personal computers or advising on organizational hardware acquisitions, helping to save time, money, and prevent frustration. Moreover, this lesson will equip you with the ability to troubleshoot performance issues and suggest potential hardware solutions.

This lesson provides a comprehensive overview of the major elements found in a computer, such as power supply, CPU, motherboard, RAM slots, storage device connectors, ports, and firmware. The key points to note:

- Computer components are sensitive and only work within precise power limits. AC power from the outlet is transformed into stable DC voltage by the power supply. Fans and heat sinks maintain their temperatures within a comfortable range.

- The motherboard is the computer's backbone, connecting and providing a platform for all other components. Its specifications limit the type and amount of components that can be incorporated into the system.

- Connectors and ports facilitate the addition of various components including GPUs, sound cards, external storage devices, and monitors. They also enable power supply to the motherboard and CPU.

- Firmware is a small program used to perform system checks, load an operating system, and conserve system settings. Modern computers typically replace the older BIOS with UEFI for a more versatile firmware interface.

- On some smaller devices, all components, including the CPU and RAM, are combined into a single system-on-chip (SoC). While this saves space, it offers less flexibility and means that a single hardware failure necessitates the entire SoC be replaced.

Users will benefit by familiarizing themselves with these crucial components, enhancing their ability to identify problems, and underscoring the need for careful handling and maintenance to prevent damage.

This lesson provides a comprehensive understanding of computer memory, specifically focusing on RAM, its types, and functionality. Readers will familiarize themselves with key terms such as DRAM, SRAM, DIMM cards, DDR specifications, and NVRAM.

The lesson highlights the reasons behind frequent refreshing of DRAM while explaining the faster, yet expensive characteristics of SRAM. It provides an understanding of the specific uses of DRAM and SRAM.

The lesson also effectively explains ROM and its purpose of storing firmware permanently. A brief overview of the Linux free command and its use in diagnosing system performance is covered.

Finally, the following themes are extensively discussed: the necessity of memory swapping when RAM is full, the role of shared memory in Inter-Process Communication, and the importance of monitoring memory usage.

Overall, by reading this lesson, users will gain a solid knowledge base around computer memory and its various functionalities, ultimately allowing them to better understand, diagnose, and optimize their systems.

This lesson provides key insights into how computer processors work, their different types (CPU and GPU), and their functions. You will learn about the binary instruction set of processors, the use of binary in electrical circuits, and the different tasks processors carry out, like arithmetic operations and data movement. The lesson also focuses on how multiple CPUs can share the workload, the concept of processor's architecture including CISC and RISC, and how to choose the right processor based on its specifications such as number of cores, and clock speed. More practical details include using commands like LSCPU and top command in Linux to get information about the processor, its usage, and troubleshooting performance issues. By the end of the lesson, you will have a better understanding of how processors function, which can assist you in tasks like system troubleshooting and efficient resource allocation.

This lesson provides comprehensive information about different storage devices, their capabilities, strengths, and weaknesses. Key points include:

1. Hard Disk Drives (HDDs): They provide large-scale data storage, but slow as compared to RAM. These are delicate, prone to damage from dust, and come as sealed units. Based on need, HDDs used in laptops can vary up to 5 TB and in servers, they can be about 30 TB.

2. Solid State Drives (SSDs): Though expensive, SSDs outperform HDDs in speed, power consumption, and reliability, often used for storing operating systems and frequently used programs.

3. USB Flash Drives: These are removable devices with smaller storage capacities, typically used for backups, data transfer, and software installation.

4. Optical Devices: which include DVD and CD-ROM drives, are less popular as storage devices today due to advancements in USB technology.

5. RAID Setup: Learners are introduced to the concept of RAID which improves system performance and data protection. It uses techniques like striping and mirroring to enhance efficiency and security.

6. Partitioning: It allows a single disk to be split into separable sections. While partitions don't improve the performance, they aid in the installation of multiple operating systems, efficient data backup, and encrypted storage of confidential data.

7. File Systems: Different formats including FAT16, FAT32, ext4, NTFS, and XFS are discussed, describing their use and compatibility.

8. LVM (Logical Volume Manager) and its Benefits: LVM allows users to add or replace disks without causing system downtime, easily resize file systems, simplify backups with snapshots, and simplify management of disk encryption.

By studying this lesson, learners will acquire a better understanding of different storage devices, how to improve their performance and data security, and effectively manage storage systems.

This lesson will guide you in understanding computer peripherals and how they interact with your computer system. You will learn about various peripherals like printers, keyboards, touch screens, speakers, and game controllers and how they communicate information between the user and the computer. The lesson covers built-in peripherals as well as the ones connected via ports and expansion slots. Attention is given to how different devices respond to different signals and the role that drivers play in this communication. You'll also learn about the importance of installing correct drivers and holding pertinent device information. The lesson delves into character and block devices and teaches how to use the lsblk command for detailed information about block devices. Finally, it provides an understanding of various device file abbreviations and file system mount points. This lesson benefits you by enhancing your understanding of how peripherals work and their interaction with computer systems.

In this lesson, you will learn:

- The lesson covered computer hardware and specifications.

- A computer is composed of several parts including power supply, motherboard, CPU, and possibly a GPU.

- The power supply ensures stable voltage for the system.

- The motherboard connects various hardware components and contains firmware like BIOS or UEFI for boot up instructions and a memory chip for system settings.

- All computers must have at least one CPU, while a GPU is optional.

- Memory holds active program code and data, with Linux swapping idle programs/data to a disk-based swap file if necessary.

- Storage devices can be hard disks, SSDs, or USB flash drives, which can be partitioned to manage data using file systems.

- Peripherals are primarily input/output devices like keyboards, monitors, and printers.

- Each device and its driver are managed via a corresponding file in the dev directory.

- The lesson teaches the structure and principles of the Linux file system.

- Linux regards almost everything, including hardware devices and kernel memory structures, as a file.

- The lesson introduces the File System Hierarchy Standard (FHS), which outlines the organization of files and directories on Linux.

- Different directories have different purposes, including essential commands, configuration files, user data, and virtual file systems.

- The lesson explains where various types of data and information are stored and how to access and utilize these storage locations.

- Being knowledgeable about the types and locations of stored information on a Linux system enhances efficiency, optimizes data storage for your organization, facilitates creation of targeted backup solutions, expedites troubleshooting, and improves system security management.

- The File System Hierarchy Standard (FHS) is a set of guidelines specifying the directory structure and contents for Linux and other Unix-like operating systems.

- The FHS is used by Linux distros, software developers, system administrators, and everyday Linux users to locate and store files.

- The key advantage of the FHS is the consistency it offers across different Linux distributions.

- This consistency decreases the learning curve when swapping between distros and enables software to run smoothly across multiple distros without modification.

- It ultimately results in a more cohesive and user-friendly Linux ecosystem.

- There are many directories as defined by the FHS, with various specific purposes.

- You can use the 'man hier' command on a Linux system to read about the file system hierarchy.

- Executable files can be binary programs or scripts stored as text that can be run from the command line.

- The directory of the executable must be included in the PATH environment variable.

- The 'which' command displays the location of the executable file that would be run if entered in the terminal.

- Executables intended to be run with super user privileges, such as the useradd command, are stored in /usr/sbin.

• System configuration files are stored in the /etc directory.

• The /etc directory contains files such as group (user group details), hostname (computer’s hostname), hosts (network host details), passwd (user account details), shadow (encrypted passwords), and services (details of services that can run on the computer).

• Users can view the system settings by looking directly at these files. For instance, ‘cat hostname’ will show the computer’s name.

• System settings can be changed by editing these files directly, though some settings have commands for easier configuration.

• Any changes to the configuration files require super user privileges.

• The /etc directory also contains user-session start scripts and configurations, such as the environment file (initial settings for environment variables), bash.bashrc file (executed for all bash shells), and the profile file (executed only for interactive shells).

• Programs and utilities store unique configuration files in /etc, typically with the .conf file extension.

• Configuration preferences for individual programs or services can be found in subdirectories under /etc, using the format of utility_name.d. Examples include cron.d and logrotate.d.

• Local configurations are usually stored as hidden files in the user’s home directory, denoted by a period prefix. This allows for single user personalization without affecting the overall system configuration.

• Examples of hidden configuration files include .bashrc (script run when user opens a terminal), .profile (script run when user logs in), .ssh directory (user-specific SSH tool configurations), and .config directory (user-specific configurations for applications).

- The File System Hierarchy Standard (FHS) standardizes directory structures on Unix-like systems, including Linux.

- System-wide configuration files are stored in the /etc directory, as per the FHS.

- System binaries that require superuser privileges are stored in /sbin or /usr/sbin.

- User commands are found in the /bin and /usr/bin directories.

- Home directores are usually located under /home.

- User-specific configurations are contained within hidden files in each user's home directory; these files begin with a period.

- Examples of these hidden files include .bashrc (executed when a user opens a terminal) and .profile (executed during login to set up the user's environment).

- The section discusses the purpose of the /boot, /dev, and /var/log directories as per the Filesystem Hierarchy Standard (FHS).

- It provides understanding on how logging works within a Linux system.

- Guides on where to locate vital information for troubleshooting a Linux system are included.

- Upon booting a Linux system, the BIOS or UEFI initializes the hardware and performs basic checks.

- The BIOS or UEFI looks for a bootloader in a reserved disk partition.

- GRUB searches for operating systems; if multiple operating systems exist, a menu is presented; if there is only one operating system, GRUB boots that operating system.

- In the case of that GRUB finds a Linux operating system, GRUB hands control to the Linux kernel, which initiates the system.

- Various system checks are performed.

- At that point, the systemd program is initiated.

- systemd manages different processes and various system services, with each process specified by a sequentially allocated PID (Process ID).

- The user eventually is shown a login screen.

- Files used in this boot process are stored in the /boot directory.

- The /dev directory contains files for all hardware devices, referred to as nodes.

- Nodes act as intermediate between device drivers and applications using those devices.

- Devices in the /dev directory are categorized as block devices or character devices.

- Block devices transfer data in large blocks and typically allow random access and buffering.

- Examples of block devices include hard drives and SSD drives.

- Character devices transfer data one character at a time without allowing random access or buffering. A keyboard exemplifies a character device.

- The first few letters of a device file indicate its device type (e.g., lp for printers, tty for terminals, hd for older IDE drives).

- Individual devices are identified by the letter following the prefix (e.g., the first SATA drive is named sda, the second one is sdb).

- Each partition on a drive has its own device file, distinguished by a number after the device name (e.g., sda1 for the first partition on the sda drive).

- The dev directory also has special files, such as /dev?null, which discards data, and /dev/zero and /dev/random, which generate sequences of zeros and random numbers, useful for securely erasing a disk to protect confidential data.

- The Linux kernel, background services, and applications periodically generate messages including warnings, errors, or status notifications.

- These messages were originally displayed on a dedicated console but now are logged to allow system administrators to review for issues, extract statistics or check for security issues.

- Unix-like systems mainly use Syslog or Journald for logging, and logs can be viewed using Linux commands such as cat, less, grep, etc. or journalctl.

- Some applications such as the Apache web server manage their own logs.

- The logs are stored under the /var/log directory structure, and log rotation takes place to manage the size of the logs files.

- Users can configure the way logs are rotated and older logs are handled by editing configuration files related to the log rotation service stored within the etsy directory.

- Various logs have meaningful names indicating what kind of messages they contain e.x. auth.log contains authentication related messages, syslog contains system messages, etc.

- Most logs are stored as plain text, but Journald uses its own binary format which is not human readable.

- Logs can be viewed using commands such as more, less, head, tail or by opening them with a text editor such as nano or vim.

- Users can determine the type of file they are dealing with by using the file command.

- The 'tail -f' command can be used to monitor or follow log files in real time for efficient issue troubleshooting.

- Some log files require superuser permissions to view them, to overcome a permission denied error users can use sudo or view as the root user.

- Grep can be used to extract specific entries from the logs.

- Kernel messages are stored in a structure known as the kernel ring buffer.

- These messages remain only in the ring buffer before file systems are mounted and the logging daemon is started during boot up.

- The ring buffer is a crucial source for troubleshooting if the system fails to boot completely.

- Use the dmesg command to view the contents of the ring buffer.

- The '-H' option to the dmesg command stands for 'human-readable', making outputs such as time stamps easier to understand.

- The ring buffer has a set size, replacing older messages with newer ones once it's full.

- Some log files, such as the wtmp and btmp files, are stored in binary format, not in plain text.

- wtmp stores successful logins, and btmp stores unsuccessful logins.

- To confirm file formats, you can use the 'file' command.

- Special Linux commands are needed to view contents of log files stored in binary format.

- For wtmp files, use 'last.' For btmp files, use 'lastb.'

- The 'journalctl' command can be used for other binary log files, allowing for filtering and searching of logs.

- Without options, 'journalctl' displays all entries from the systemd journal, comparable to the 'less' command.

- Several commonly used 'journalctl' options.

  - '-b' shows logs from the last system boot.

  - '-k' shows messages from the kernel.

  - '-u' shows messages from a specified unit. Units are akin to services.

  - '-f' displays recent messages and updates as new ones arrive.

    - To exit this output, type 'control c'.

  - '--since' and '--until' allow display of messages from specific time and date ranges.

  - '-p' displays messages of a specified severity level or below.

- Severity levels range from zero to seven, with zero as an emergency and seven as a debugging message.

- To view all messages with a severity level of error and lower, use 'journalctl -p 3'.

- To view all messages from the network manager unit since a specified date, for instance, May 10, 2024, use 'journalctl -u NetworkManager.service --since "2024-05-10"'.

- Learned about essential files for booting a Linux system, managing devices through files, and basics of system logging.

- Booting files are stored in the /boot directory, which include the Linux kernel, the initial RAM disk, and GRUB bootloader's configuration files.

- Device related files are in the /dev directory; each device has a file for application connectivity via its driver.

- Devices are characterized as either block or character devices, /dev directory also contains special files like /dev/null.

- System logging messages are usually saved in the /var log directory.

- The older syslog stores messages as plain files, while the newer journald stores logs in binary format, readable with the journalctl program.

- Binary logs are accessible through their specific utilities such as last and lastb.

- Logs are rotated to prevent them from becoming too large, controlled by the etc/logrotate.conf file and the /etc/logrotate.d directory.

- Explored the kernel ring buffer and learned to view it using the 'dmesg' command.

- Virtual file systems are memory structures used by the kernel that function like directories containing files.

- The content of these systems is stored in memory and not retained when the system shuts down.

- Virtual file systems contain information about running processes, kernel configuration settings, and system hardware.

- Many Linux commands use these structures to gather data; for instance, the LSCPU command retrieves CPU data from the PROC CPUINFO file.

- Admins can alter kernel configurations by directly editing these files, though changes won't remain after a reboot and can cause system instability.

- The more secure alternative is using the sysctl command to adjust kernel parameters.

- Permanent changes to the kernel configuration can be made by editing the /etc/sysctl.conf file.

- Linux used to hold kernel structures under the /proc directory, but newer versions use the /sys directory for better organization.

- Linux manages RAM and swap space together as virtual memory.

- The free command displays memory usage information.

- systemd starts a process for each service when the system is booted and a new process for every user session.

- Processes can start other processes. Each process gets resources (memory and CPU time) allocated by the kernel.

- Every process has a unique ID, known as PID or Process ID.

- Processes are hierarchically arranged with parent processes possibly having multiple child processes.

- Parent Process ID (PPID) is the identification of the parent process.

- systemd, acting as initialization system, is the top level of the process hierarchy and all others are its child processes.

- The pstree command displays the hierarchy and the PS-F command lists the processes of a current shell session.

- All  rocesses can using the ps -ef command.

- The top command is useful for troubleshooting performance issues as it provides information on resource-heavy processes. The screen dynamically refreshes showing the currently running processes and sorts them by different parameters (PID, memory usage, etc).

- The uptime command gives system uptime since last boot, number of connected users, and load averages for the last 1, 5, and 15 minutes.

- A healthy system usually has a load average equal to or less than its number of CPUs; a high load average signals CPU overload.

- The /sys directory is used to store kernel configurations and maintains a strict structure.

- Some information in the /sys directory duplicates that found in the /proc directory, required for backward compatibility.

- The Linux virtual file systems of /proc and /sys are managed by the Linux kernel.

- These virtual file systems provide information on the system's current state and kernel configurations.

- The /proc and /sys file systems offer insights into running processes, kernel configurations, and hardware details.

- Many Linux commands, including lscpu, free, and uptime, retrieve data from these virtual file systems.

- The process hierarchy is managed by systemd.

- Tools such as ps, top, and pstree are used to view running processes on the system.

In this lesson, you will learn:

- The ability to connect and share information is a fundamental aspect of modern computing.

- This lesson will cover essential networking terms and concepts, focusing on their application in Linux.

- Participants will learn to locate information about their network and adjust network and internet-related settings on a Linux system.

- Most computers currently connect to the internet, therefore few operate as standalone devices.

- Developers are likely to create applications that communicate over a network.

- Systems administrators need skills for troubleshooting and managing networks.

- Understanding marketing involves navigating acronyms and technical jargon.

- By the end of the lesson, participants should understand how a computer connects to the broader world.

This lesson provides a deep dive into the evolution and functioning of computer networks, from basic systems connected by cables to modern-day internet communications reliant on the OSI (Open System Interconnection) and TCPI (Transmission Control Protocol/Internet Protocol) models. Users will understand various ways devices can be connected, such as fiber optics, radio waves, and lasers.

The lesson explains multiple layers of the OSI model and how these facilitate effective device communication. Similarly, it elucidates the four key layers of the TCPI model.

The lesson provides practical illustrations, such as how a browser request navigates through these layers, from application, transport, network, to the data link layer, both while making the request and receiving the response.

This lesson will leave users with a solid understanding of networking concepts, invaluable for anyone interested in IT and telecommunications.

This lesson covers the roles and protocols of various network layers.

On the application layer, protocols like HTTP, HTTPS, SSH, FTP, and SMTP manage end-to-end communications for various applications. The transport layer, using protocols like TCP and UDP, divides data into packets and controls their transmission across the network, ensuring their delivery and sequencing. The network layer's role involves routing packets and uses protocols such as IPv4, IPv6, and ICMP. Lastly, the data link layer sends data to physically connected devices, using connections like Ethernet and Wi-Fi, ensuring the data reaches the correct place, through local MAC addresses.

You will learn the functions of these network layers and how they play significant roles in data communication.

This lesson provides key insights into how communication between devices in networks has evolved from using dedicated links with circuit switching to the more contemporary method of packet switching.

You will learn how packet switching works by dividing data into small packets for individual transmission which optimizes network resources efficiently. Also, you'll understand the role of the frame, packet composition and the importance of the MTU (Maximum Transmission Unit) setting for limiting packet size. The lesson will discuss the route variation of packets depending on network conditions and the impact of packet loss on communication quality.

By taking this lesson, you will gain a better understanding of how efficient data transmission is achieved in modern networks.

In this lesson, you will learn:

- Internet routing uses IP addresses to locate devices on the Internet.

- The Domain Name System (DNS) converts human-friendly domain names like LinuxTrainingAcademy.com into these numeric IP addresses.

- Applications use a Linux function called the resolver to submit the domain name and get back the corresponding IP address, a process known as address resolution.

- Locally, computer names can be converted to IP addresses using the etchosts file. This file contains known host names and their matching IP addresses.

- Multiple host names can share the same IP address, as seen when several websites are hosted on one Linux server.

- The resolver first checks the etchosts file when finding the IP address for a domain. If the required name isn't there, the request is forwarded to a DNS server mentioned in the etcresolve.conf file.

- DNS servers hold information about domains in a text file containing several types of records, including: A records (domain name and IPv4 address), AAAA records (domain name and IPv6 address), CNAME records (for aliasing), NS records (authoritative DNS servers for the domain), MX records (where email for the domain should go), text records or TXT records (informational text about the domain), and pointer records (for reverse DNS, mapping IP back to a domain name).

- The Linux host command can be used to perform DNS lookup. The dig command provides detailed results, helpful for troubleshooting network issues.

- If a name cannot be resolved, the host command will show an error message.

- The learned commands and configuration files are useful tools for diagnosing and rectifying network issues.

In this lesson, you will learn:

- The ping command is useful for troubleshooting networks.

- It sends an echo request packet to a specified IP address or hostname.

- A message is displayed upon receiving a reply, indicating whether the network can contact the host.

- Ping will continue sending echo requests until stopped with Ctrl-C.

- The -c option can limit the number of echo request packets sent.

- Sending exactly four echo request packets to www.google.com would be achieved by 'ping -c for www.google.com'.

- If four packets are transmitted and received with 0% packet loss, the network connection is functioning properly.

- A 0% packet loss means there are no immediate connectivity issues between the device and www.google.com.

In this lesson, you will learn:

- The link layer is the lowest layer in the TCP IP model, which manages data transmission within a local physically connected network segment.

- Devices on this layer use 48-bit local addresses known as MAC addresses, which are assigned by the network interface card's manufacturer.

- This layer handles three types of traffic:

    - Unicast traffic for a single recipient.

    - Broadcast traffic for all devices on the network.

    - Multicast traffic for a group of subscribers.

- Packets, referred to as frames at this level, are transmitted across the network; for unicast messages, devices accept packets with their own MAC addresses.

- The Linux 'IP' command is used to view and configure network settings, replacing the deprecated 'ifconfig' command.

- The 'IP link show' command provides a list of all network interfaces on the system, including the loopback interface and the network card interface (named 'ens' on modern systems and 'eth' on older systems).

- Each interface's status and settings, including its MAC and broadcast addresses, are displayed under its listing.

- Linux systems can utilize a feature called 'bridging' to connect multiple networks at the link layer.

In this lesson, you will learn:

- IPV4 is a protocol used at the network layer for global communication.

- IPV4 addresses are 32-bit numbers that uniquely identify devices and are represented as four decimal numbers, each from 0 to 255.

- The IP address 192.168.220.128 is an example of an IPV4 address, with numbers separated by periods.

- IPV4 allows approximately 4.3 billion unique addresses managed and allocated by the Internet Assigned Numbers Authority (IANA).

- Devices need a unique address from IANA to be globally accessible on the internet.

- Certain number ranges are reserved for special purposes such as broadcast, multicast, and private network addresses. Private addresses are unique within their own network only.

- The 192.168.0.0-16 network range, often used by home routers, is reserved for private networking.

- IP addresses of network interfaces are viewed with the IP command, with 'ip-4addrshow' displaying the IPv4 and the broadcast address for each interface. Its output only restricts to IPv4 addresses.

- The command results indicate that the loopback interface has an address of 127.0.0.1, and the ens33 interface has an IP address of 192.168.220.128.

In this lesson, you will learn:

- Large networks are often divided into smaller units known as subnets to enhance performance and simplify management.

- Each subnet has a unique range of IP addresses.

- Communication between two devices on the same subnet does not require a router, improving speed and reducing congestion.

- If devices on different subnets need to communicate, their messages must pass through a router.

- The network administrator determines how many bits of the 32-bit IP address will identify the subnet and host, specified using a subnet mask.

- Bits in the subnet mask set to 1 represent the IP address parts for the subnet identifier, while those set to 0 identify the host.

- Subnet masks are usually represented as 4-decimal numbers with each number constituting 8 bits.

- Messages must pass through a router if sending and receiving devices are not on the same subnet.

- Classless inner domain routing notation is an alternative way of specifying subnet and host bit allocation.

- The ipaddr show command displays the subnet prefix size in classless inner domain routing format.

- Private IP addresses are typically used in a private network, with multiple devices often sharing one public IP address for external communications through Network Address Translation (NAT).

- NAT translates private IP addresses to a global IP address for outgoing communications and vice versa for incoming communications, a process that is invisible to the devices communicating.

- IP masquerading is a common type of NAT that hides the internal network structure, enhancing security but not eliminating the need for a firewall.

- NAT introduces a small delay in communications, typically negligible in most cases.

In this lesson, you will learn:

- IPV4 routing is a protocol that helps in sending a packet from its source to its destination.

- If a packet's destination is outside the current network, it is routed through a router; sometimes, it may pass several routers in a sequence of hops.

- Most home networks use a single router, often provided by the internet service provider (ISP).

- Each device has a routing table containing a list of directly accessible subnets, specific network routers, and a default gateway (router).

- The software checks the routing table to determine how to send a packet, either directly, via a specific network router or through the default router.

- You can view your routing table with the 'ip route show' command and add a default route using the 'ip route add default' command.

- IP addresses can be manually or automatically assigned to devices on a network.

- Many network administrators prefer automatic assignment of IP addresses by a DHCP (Dynamic Host Configuration Protocol) server.

- The DHCP server, which is likely your router at home or a dedicated server in a large organization, also provides configuration information like the default gateway and DNS server address.

- DHCP servers use automatic, dynamic, or manual methods to allocate IP addresses. Automatic assignment permanently assigns an IP address, dynamic assignment assigns it for a limited time and manual assignment is done by an administrator.

In this lesson, you will learn:

- IPv6 is a newer version of the IPv4 protocol, and both are currently being used alongside each other.

- IPv6 was created because the internet outgrew the 4.3 billion address limit imposed by IPv4.

- IPv6 uses 128-bit addresses, allowing for over 10 to the 38 unique devices to be connected.

- Reduction in reliance on network address translation and enhanced performance and security are other benefits of IPv6.

- The first 64 bits of an IPv6 address make up the routing prefix, which includes subnet information.

- There are three types of IPv6 addresses: global unique address, unique local address, and link local address, each distinguished by set hexadecimal identifiers.

- The last 64 bits of an IPv6 address, known as the interface identifier, identify the specific device.

- IPv6 addresses can be assigned either manually or automatically through DHCPv6 or SLAAC (Stateless Address Autoconfiguration).

- When an IPv6 device connects to a network, it automatically configures a link-local address and performs duplicate address detection.

- Depending on whether the router is configured with DHCPv6 or SLAAC, it either provides full internet configuration details or the global prefix and prefix length.

- The ping command or its IPv6 version (ping6) can be used for troubleshooting IPv6.

- To view IPv6 addresses on a system, the ip command with the -6 option can be used.

In this lesson, you will learn:

- Sockets act as a communication point for two applications to exchange information; one application acts as a server listening on a socket, while the other acts as a client requesting a connection.

- Sockets can be on the same device, local network, or the internet. Their operation remains the same irrespective of location.

- Examples of socket use include a database server listening for requests or a web browser connecting to a web-server.

- There are three main types of sockets: Unix, UDP and TCP. Unix sockets are used between processes on the same host, UDP sockets are fast but may not be reliable, and TCP sockets ensure data arrives in correct order.

- An IP address can have multiple sockets, each running on a different port. Servers listen on predefined ports, while client port numbers are usually randomly generated.

- In some scenarios, the server may listen for requests on one port, and then open a different port to handle a specific request, keeping the original port available for new incoming connections.

- Server port numbers can usually be configured, with standard ports often used for common services - like HTTP servers listening on port 80 and SSH servers on port 22.

- For Linux, the 'ss' (socket statistics) command provides information about sockets in use. It can serve various functions with different inputs like -L for list of listening ports, -P for process IDs using the sockets, and others for socket usage summary, IPv4/IPv6, TCP, and UDP.

In this lesson, you will learn:

- The lesson taught the basics of networking, including the functions of networks and routers.

- It included instructions on how to query network and DNS configurations on Linux systems.

- The context of OSI and TCPIP models was explored, with an emphasis on understanding how each layer helps with network communication and the common protocols used in each layer.

- Also included was the structure of IPv4 and IPv6 addresses, subnetting, and IP address allocation through DHCP.

- Explanation was given on how DNS works to convert domain names into IP addresses, including the use of Host and Dig tools for DNS lookups.

- Instruction on how to use IP, ping, and SS commands on Linux to show networking information and troubleshoot network issues was provided.

In this lesson, you will learn:

- The lesson covers foundational concepts of Linux security, focusing on user accounts and privileges.

- Different types of user accounts in Linux are explored, including superusers, system users, service accounts, and standard users.

- The process of assigning user IDs and group IDs in Linux is explained.

- How Linux manages user permissions through user groups and accesses superuser privileges using commands like sudo and su is covered.

- Key system files are examined to understand their role in user account management and security.

- The aim of the lesson is to enable confident management and security of user accounts on a Linux system.

- Understanding Linux user security is beneficial regardless of the user role; it informs system limits, aids secure software development, and supports efficient configurations, protection of confidential information and safeguarding of system resources.

In this lesson, you will learn:

- Linux security controls access to resources, mainly through file permissions.

- The system of granting permissions to users is inherited from Unix and is particularly effective.

- Each Linux user has a username and a unique numerical user ID (UID).

- UIDs vary from 0 to 999 for system users, and 1000 and above for standard users.

- UID 0 is always the root or super user; UIDs 1 to 99 are for system accounts; UIDs 100 to 999 are for service accounts; and UIDs 1000 and above are for regular user accounts.

- System users are typically created during setup to run specific system tasks and do not require super user privileges.

- Service or application users often run application services like web and database servers, and like system users, do not require super user privileges.

- Standard users usually have a home directory under '/home' and usually have a login shell, unless only connecting to login to a single application.

- Important distinction exists for root user, whose home directory is under '/root' as it's part of the always-mounted root filesystem.

- Understanding Linux's user and group configurations is essential for finer control over user access management.

In this lesson, you will learn:

- Linux defines user groups, each with a group name and a Group ID (GID).

- User groups can represent departments within an organization, granting access to specific files to all members.

- Special groups, like the sudo or wheel group, include users with administrator privileges.

- Users can be members of multiple groups.

- Every user account has a main group correlating with the user's primary function.

- On user creation, a group with the same name is created; this is by default the user's main group.

- The initial group assignment can be changed.

- The root user's primary group, for example, is called root with a GID of 0.

In this lesson, you will learn:

- When an administrator creates users, they specify the shell for running command line instructions, typically bash.

- The user's working shell type can be seen by displaying the shell variable contents.

- Some users may prefer alternative shells to bash, like csh or zsh which have different syntax, behavior, and responses to keys.

- The available shells vary by distro and might need to be manually installed if not default.

- To see installed shells, view the contents of the etc-shells file.

- If a desired shell is not listed, it can be manually installed. Apt install is used to install ksh on Debian-based distro, while dnf install is used on RHEL-based distro.

- A user can change their default login shell with the chsh command, which will take effect upon next login.

- The dash s option to chsh can be used to enter the full path as an argument.

- A temporary switch to a new shell can be initiated by typing the shell name, initiating a new process until typing exit or closing the terminal.

- User accounts without a login shell will have a dummy shell set, typically user sbin-no-login.

- During account creation, a user's home directory is specified, typically under forward slash home. This becomes the current working directory upon login.

- Users have full control over their home directories, and can be granted access to other directories by an administrator if needed.

- Each user has a primary (default) group influencing default permissions, which can be changed by an administrator. E.g., all staff in the accounting department may be assigned to a primary group called "accounting."

- The 'id space dash g n' command displays the user’s primary group.

In this lesson, you will learn:

- The Linux system has several commands to obtain information about user accounts.

- The "id" command displays user ID, username, group ID, primary group name, and additional group affiliations. It can be used to get information about other users as well.

- The "who" command reveals a list of currently logged in users along with their usernames, terminal, working location, and login time.

- The "w" command also lists logged-in users but gives additional information like CPU usage by user sessions and also includes a header with details about the system's uptime, number of logged users, and the load average.

- One can also get information about a specific user by specifying the username as an argument.

- The "last" command gives users' login history, and it can be filtered for a specific user by providing the username.

- Unsuccessful login attempts can be viewed by using the "last B" command.

In this lesson, you will learn:

- Only one user on a Linux system has super user or administrator privileges - the root user.

- Other trusted users may be allowed to administer the system when the administrator cannot be available.

- Multiple people using the same username and password is risky due to difficulty in tracing responsibility in case of compromise.

- Three ways exist to perform administrative tasks - provided your user has the appropriate privileges.

- It's possible but not recommended to login directly as root as it may lead to system destabilization.

- Log in as a standard user for everyday tasks and access elevated privileges temporarily for administrative tasks.

- First method of getting super user privileges is through the su (switch user) command which starts a new shell as a different user.

- Use su space dash to switch to the root user, command prompt changes from a dollar sign to a pound sign to signify super user workings.

- Use sudo to gain super user access for single actions, it's allowed only if granted by an administrator.

- The /etc/sudoers file configures the sudo command and can only be viewed either as a root user or by using a sudo command.

- First execution of a sudo command prompts you to enter your password; password isn't asked every time you invoke sudo.

- The /etc/sudoers file should never be edited directly, instead use vi-sudo command which checks for syntax errors and locks the file to prevent concurrent edits.

- Files under /etc/sudoers.d directory contain additional rules for specific cases.

- You can give a user sudo privileges by adding them to a Linux group named sudo, as this grants super user privileges to anyone in the sudo group.

- It's better to use sudo rather than switching to the root user unless carrying out administrative tasks that require running many commands.

In this lesson, you will learn:

• User configurations are stored in files including the passwd, shadow, group, and gshadow files.

• These files should not be edited directly but managed using system administration commands.

• Passwords were formerly stored in the passwd file but, due to security issues, now reside in the shadow file.

• The passwd file contains categories like username, encrypted password, UID, and GID of a user’s primary group.

• The GECOS field in the passwd file includes personal user information but is largely optional. It can be updated using the chfn command.

• The passwd file also holds a user’s home directory and login shell details.

• The group file keeps group data. Group membership is automatic if a user’s primary group ID matches a group ID in the file.

• The shadow file stores encrypted passwords and password change policies, and can only be accessed by the superuser or certain authentication processes.

• The shadow file utilizes one-way hash encryption with a salt for enhanced security.

• The Linux passwd command is used to change user passwords.

• The gshadow file regulates group accessibility and can only be read by the superuser. It contains group name, encrypted group password, group administrator, and a list of group members.

In this lesson, you will learn:

- The lesson focused on managing user accounts on Linux.

- Each Linux user has a username and is assigned a unique user ID (UID).

- Other user properties include the primary group, login shell, and home directory.

- Users can belong to one or more groups, each with a unique Group ID (GID). Grouping users simplifies access control when multiple users require similar permissions.

- UID 0 is assigned to the superuser, whose username is root.

- UIDs from 1 to 999 are for system accounts. Some older systems use the range 500 to 999.

- UIDs 1,000 and above are for standard users.

- Administrator privileges can be accessed by several methods: logging in as root, using the 'su' command to switch to root, or prefixing a command with 'sudo' to temporarily act as root - all depending on permissions.

- Methods to get information about users includes using 'id', 'who', 'w', or 'last' commands.

- User configurations are available in specific files.

In this lesson, you will learn:

- The lesson covers administering users and groups in Linux.

- Focus is also put on configuring default settings for new users.

- User management is vital in system administration, particularly in multi-user environments.

- As a Linux system administrator, it's crucial to simplify the process of adding new users and ensuring they have necessary files and permissions.

- Efficiently grouping users enables easy management of those with similar needs, improving job efficiency.

In this lesson, you will learn about four essential data storage files on a Linux system: passwd, shadow, group, and gshadow.

• passwd stores user account information, including usernames, user IDs, optional user details, the path to the user’s home directory, and the default shell.

• shadow contains encrypted passwords for users, which can only be accessed by those with superuser privileges. It also stores password-related details such as the last password change, minimum and maximum password age, password warning period, password inactivity period, and account expiration date.

• group stores group information, including group names, passwords (if any), group IDs, and a list of users who are members of that group.

• gshadow stores encrypted passwords for groups and lists of users who can administer the group and who belong to the group.

• These files should not be manually edited but should be altered using appropriate tools provided by the Linux distribution.

In this lesson, you will learn:

• Superuser or root privileges are required to add new users to a system.

• The simplest way to create a new user is to specify the username.

• After creating a user, you need to assign a password to the account.

• Users can change their own passwords, but changing passwords for other users requires superuser privileges.

• Creating a user updates certain system files that store user and group information.

• By default, a new group with the same name as the user is automatically created and set as the primary group.

• Users are often added with default settings, but various options are available for customization:

• Adding comments to the user profile

• Creating the user’s home directory

• Specifying the location of the home directory

• Setting the number of days between password expiry and account disabling

• Setting the primary group (the group must already exist)

• Specifying additional groups

• Preventing a home directory from being created

• Specifying the login shell

• Assigning a user ID (UID)

• Superusers can change or delete passwords, force users to change their passwords, and lock or unlock accounts using appropriate commands and options.

• Users can change their own passwords without encountering permission issues.

• Users can view a list of groups they belong to; if no username is specified, it displays the current user’s group membership.

• User details such as user ID (UID), username, primary group ID (GID), group name, and a list of other groups the user belongs to can be viewed.

• To modify a user’s configuration after creation, appropriate commands are used, offering similar options as when adding a user.

• Users can be removed from the system, and options are available to delete their home directories and mail spool files if they exist.

• Superuser privileges are required for most of these administrative tasks. They can be performed either as the root user or by using sudo.

In this lesson, you will learn:

- Default behavior for creating new users can be adjusted by modifying certain configuration files.

- The /etc/default/useradd file sets defaults like new user's home directory and login shell location.

- This file can be directly modified with a text editor, uncommenting lines to activate them.

- Changes can include switching the default login shell from bin sh to bin bash.

- The /etc/login.defs file provides additional default configurations like user ID number ranges and password aging controls.

- You can directly modify the /etc/login.defs file using a text editor. The file includes comments to explain each setting.

- The /etc/skel directory, or skeleton directory, has files that are copied into a new user's home directory upon user creation.

- Common files in the /etc/skel directory include a .profile file, a .bash_logout file, and .bashrc, all running scripts at different user actions.

- Additional files or directories can be added to the /etc/skel directory to ensure new users have necessary files in their home directories. These commonly used files can be modified to suit your organization's needs.

In this lesson, you will learn:

- Linux has commands for managing both users and groups.

- The 'group add' command can create a new user group, such as 'dev' for developers.

- The '-g' option can specify the group ID (GID) for the new group instead of automatically assigned one.

- Specifying a GID can ensure consistency across multiple systems, critical in environments using file sharing, network systems or centralized authentication services.

- Consistent GIDs can prevent inaccessibility of files/directories and inconsistencies in user permissions when moving between systems.

- The 'group del' command can remove existing groups from the system.

- Groups can't be deleted if used as the primary group for any user.

- To remove the 'dev' group, the command is 'group del dev'.

• The lesson covers managing users and groups on a Linux system.

• The passwd file on a Linux system stores user account information such as user ID, home directory location, and login shell.

• The shadow file keeps encrypted passwords for users.

• The group file holds data about the groups on the system, while the gshadow file stores encrypted passwords for groups.

• Commands like useradd, usermod, userdel, and password can be used to create, modify, delete user accounts and manage passwords.

• Group creation and deletion are managed by the groupadd and groupdel commands respectively.

• Default settings for new users can be customized by editing the default useradd file, the login.defs file, and the skel configuration directory.

- The lesson covers managing file permissions and file ownership on a Linux system.

- Linux systems allow access by multiple users and therefore require segmentation of access.

- It is vital for the system to track both file ownership and the authority to act on each file.

- Users need mechanisms to keep their files private while also sharing resources for collaboration purposes.

- Linux uses a flexible three-tiered permissions system for this: the file owner, the group owning the file, and other users on the system.

- The lesson will teach how to obtain detailed information on files/directories, set permissions, and modify ownership.

- Knowledge of file permissions and file ownership on Linux helps to grant user privileges, restrict unwanted actions, setup applications/services with the right privileges, secure the system against unauthorized access, ensure users' privacy, and promote sharing and collaboration.

- Understanding file permissions is crucial before learning how to change them.

- The 'ls' is a command used to list a directory's contents, including files and subdirectories.

- Depending on the terminal configuration, terminal outputs may be color-coded to distinguish between files and directories.

- The 'ls' command offers additional functions using options like 'dash l' for detailed information, 'dash a' for showing hidden files, 'dash h' for human-readable file sizes, 'dash r' for reversing output order, 'dash t' for sorting files by modification time, and 'dash s' for ordering files by size.

- 'ls dash l' lists files in a long format, useful for viewing file permissions and ownership.

- The 'ls dash l' result displays information in columns: file permissions, number of links, file's owner, owning group, file size, last modification date and time, and the filename.

- To list specific files, use 'ls dash l' followed by the file names.

- You can use the asterisk wildcard to list files that start with a letter or have a certain extension.

- 'ls dash l' followed by a directory name shows the directory's contents; to view the directory's details, use 'ls dash l d' followed by the directory name.

- 'ls dash l' might not show hidden files. Use the 'dash a' option to see these files.

- Hidden files start with a period or "dot"; this includes special hidden files dot (.) and dot dot (..) that point to the current and parent directory respectively.

- File permissions are crucial to the security of Linux as they control access.

- To understand permissions, you have to understand how listing files in long format works.

- The first column in a long format listing is the Permissions field, a 10-character string such as "-rwx", "-r-x", "-r-x".

- The first character indicates the file type: "-" for a normal file, "D" for a directory, "L" for a link, "B" for a blocked device file, "C" for a character device file, "S" for a socket file.

- The remaining nine characters represent permissions for the user, group, and others, in that order. The most common permissions are "R" (read), "W" (write), and "X" (execute).

- In the context of directories, these permissions have additional meanings: 'read' allows you to list the directory contents, 'write' lets you create, rename or delete files in the directory, and 'execute' lets you access the directory and its contents. 

- The permissions for every file or directory can be set for the owner, the group, and others. This structured permission system enhances the overall security by managing user privileges.

- An example of a file named 'permx.sh' is given with different user permissions: 'RWX' for the owner, 'RW' for the tech group, and 'R' for other users.

- Similarly, an example of a directory named 'my files' is given where the owner has 'RWX' permissions, the tech group, and other users have 'RX' permissions.

- These examples highlight how setting file and directory permissions allows for nuanced control over who can access and manipulate data.

- The command to modify file and directory permissions is "chmod", which stands for change mode.

- You can use chmod in two ways: symbolic mode and numeric mode.

- Symbolic mode allows you to modify one permission without affecting others.

    - Abbreviations specify who the change affects: U(user), G(group), O(others), A(all).

    - Symbols indicate the actions: + (grants a permission), = (sets a permission).

    - An example is: chmod g+w work.txt (this gives the group write permissions).

- Numeric mode allows you to set all permission values for a file or directory concisely.

    -  It's efficient once you memorize the most commonly used permission values.

    - Permission values: read(4), write(2), execute(1), none(0).

    - They are added to create permission sets, like read and write form 6 (4+2).

    - In chmod 755, the first digit (7) represents owner's permissions, second digit (5) represents the group's permissions, and third digit (5) represents everyone else's permissions.

- To modify permissions for an entire directory and its contents, use the recursive option (-R) of the chmod command. Be cautious as improperly setting permissions can have severe consequences.

- The ls-l command is used to view file permissions in long form.

- The long listing format of the ls command displays a 10-character permission string.

- The first character of the permission string indicates the file type.

- The remaining nine characters are divided into three sets, each representing a different type of permission.

- The first set of three characters represents permissions for the file's owner.

- The second set of three characters represents permissions for the group that owns the file.

- The final set of three characters displays permissions for all other users on the system.

- The chmod command can modify file and directory permissions in both symbolic and numeric modes, enhancing system security.

- File ownership in Linux is subdivided between a user and a group.

- File owners are listed via the "ls -l" command.

- A user can belong to multiple groups, these can be viewed via the "groups" command.

- To view all groups on your system, use the "getent group" command.

- To view users belonging to a specific group, use the "group mems" command.

- The "chown" command is used to change the ownership of files and directories.

- To change both user and group ownership, use "chown username:groupname filename".

- Changing file ownership requires administrative rights, usually needing the "sudo" command to run.

- If you want to change only the file's owner without altering the group, omit the group name in the command.

- To change only the group owner, use the "chgrp" command.

- As a file's owner, you can change the group ownership without elevated privileges, as long as the new group is one you belong to. If not, sudo is required.

- Three special permissions exist besides usual read, write, and execute permissions: SUID, SGID, and the sticky bit.

- SUID is represented by 'S' and SGID also uses 'S' while the sticky bit is represented by 'T'. These apply to different scenarios hence no confusion.

- SUID applies to user permissions, and SGID applies to group permissions.

- Special permissions can be set using chmod in symbolic and numeric mode.

- In numeric mode, an extra digit (representing the special permission) is added in front of the usual three-digit chmod command: SUID - 4, SGID - 2, and sticky bit - 1.

- SUID when set allows a file to be executed with the privileges of the file's owner, regardless of who runs it, for temporary elevated privileges.

   - For instance, it can be set by using chmod 4755 [file name] or chmod u+s [file name] in symbolic mode.

- SGID when set allows files or directories to inherit privileges of the group that owns them.

   - For implementation, one can use chmod 2755 [directory name] or chmod g+s [directory name] in symbolic mode.

   - The behaviour of SGID varies according to whether it is applied to a file or directory.

   - On a file, the process created by executing the file inherits the group ownership of the file.

   - On a directory, all new files created within the directory inherit the group ownership of the directory, useful for collaborations.

- The sticky bit ensures files within a directory can only be deleted or renamed by the file's owner, the directory owner, or the root user.

   - It can be set using chmod 1777 [directory name] or chmod o+t [directory name] in symbolic mode.

   - It replaces the execute permission for 'others' in the directory permission set, thus preventing accidental or malicious removal of files.

- Linux files and directories have both a user owner and group owner, each with unique access privileges.

- The long listing format of the LS command (LS -l) can be used to view ownership details.

- The CHOWN and CHGRP commands are tools to change user or group ownership of files and directories.

- Linux has special permissions beyond the standard read, write and execute rights; these include SUID, SGID and the sticky bit.

- SUID allows a file to run using the owner's privileges, regardless of who executes it.

- SGID makes a file run with the group's rights or makes new files in a directory inherit the directory's group ownership.

- The sticky bit ensures that only the file's owner can delete or rename files in a directory, even if others have write permission to the directory.

In this lesson, you will learn:

- The lesson covers the role of temporary files and directories in a Linux system.

- Programs like user-run applications or system services use temporary files and directories for operations.

- Linux has designated locations for these temporary files and directories.

- The lesson includes information on where this data is stored and how it's managed.

- It also introduces links on Linux such as hard links and soft/symbolic links.

- Learning about links helps in quick access to frequently used files or directories, thus improving navigation and file management.

- Understanding temporary files helps manage system storage, set secure access policies for programs, and troubleshoot application or system issues.

- Utilizing links helps create shortcuts without duplicating data, organize files and directories, and manage links for security and user permissions.

In this lesson, you will learn:

- Temporary files store data needed by programs or services to function, improving their efficiency and performance.

- The File System Hierarchy Standard (FHS) defines where temporary files should be stored on Linux systems.

- Three directories used for temp files are /temp, /var/temp, and /run.

- /temp directory stores temporary files created by applications which are generally erased upon system reboot; contents are not preserved between sessions.

- /var/temp stores temporary files that need to be preserved between reboots; programs or services clean up these files as needed or the system cleans up after 30 days.

- /run directory contains runtime data and socket information for the currently booted session, and it's cleared between system boots.

- The sticky bit permission in Linux ensures files in the /temp and /var/temp directories can only be deleted by their owners, thus protecting users' temporary files and maintaining system stability.

- To create a shared directory with sticky bit, use commands such as mkdir and chmod 1777.

In this lesson, you will learn:

- Links on Linux are special types of files that act as shortcuts to frequently used files or directories.

- There are two types of links: hard links and symbolic links.

- Hard links are additional names for an existing file that points directly to the same data on a storage device.

- Unlike copying a file, which creates a separate file, a hard link allows multiple locations to access the same data without using extra storage space.

- Hard links can be created with the 'ln' command using the syntax 'ln target link name', where the target is the existing file and link name is the new file. The target file must already exist and must be a file, not a directory.

- A hard link and its target must reside on the same file system.

- All changes to the file in one directory will be reflected in all other directories. Therefore, only one copy of data is needed.

- Hard links are not copies of data, rather, they are different paths to the same file.

- Linux files use a data structure called an inode to store file information. This includes file size, device ID, user ID of file owner, group ID of file owner, file mode or permissions, timestamps, link count, and pointers to the disk blocks containing the file's data.

- Inodes contain pointers to the data blocks that make up the contents of the associated file.

- To view the inode number of a file, use the '-i' option with the 'ls' command.

- You can manage hard links just like regular files. You can move them with the 'mv' command or remove them with the 'rm' command.

- Moving a hard link doesn't break it or affect its functionality, while deleting a hard link does not delete the data on the disk as long as there's at least one other link pointing to that data.

- If you delete all the hard links that point to a piece of data, then that data will be deleted.

In this lesson, you will learn:

- Linux systems support both hard links and symbolic links.

- A symbolic link or symlink is a file that points to another file or directory, similar to a shortcut.

- Symbolic links are helpful for creating shortcuts to essential files, redirecting to network storage, or managing software versions.

- A symbolic link is created using the ln command with the dash s option, formatted as: ln -s [target] [link name].

- Symlinks are different from hard links. They point to the path of the target file, can link to files or directories, and can refer to different file systems, while hard links point to the inode of the file, and can only link within the same file system.

- Operations performed on symbolic links access the target file.

- When moving a symlink, it might break as it stores the path relative to its location. To prevent this, it's preferable to specify the full absolute path when creating the link.

- Links using relative paths are useful in a project directory, so when the directory is moved or copied, the links still operate.

- Broken links can be identified using the find command with the "-xtype l" option.

- To fix a broken symlink, it needs to be deleted and recreated.

In this lesson, you will learn:

- System services and user programs create temporary files for operations.

- The file system hierarchy standard dictates where Linux stores these temporary files.

- 'Temp' stores short-term temporary files, 'vartemp' stores longer-term temporary files, and 'run' stores runtime variable data cleared upon reboot.

- 'Temp' and 'vartemp' directories have a special permission, the sticky bit, which allows users to share access to temporary files without deleting files belonging to others.

- Links, or special pointer files, act as shortcuts to frequently used files or directories.

- There are two types of links: hard links and symbolic links (also known as symlinks or softlinks), created using the 'ln' command.

- Hard links point directly to data on disk, while symbolic links point to the paths of other files or directories.

- Hard links can only link to files, must reside on the same file system as their target, and can't break as they point directly to inodes.

- Symbolic links can link to files or directories, can point to a target on a different file system, and can potentially break as they store the paths to their targets.

In this lesson, you will learn:

- To become LPI Linux Essentials certified, it's mandatory to pass the LPI Linux Essentials 010 exam, current version 1.6, with an exam code of 010-160.

- The exam comprises 40 multiple-choice questions to be completed within 60 minutes. It is a closed book exam with no aids allowed.

- The scoring ranges from 200-800 points, with a minimum of 500 points required to pass.

- The exam is accessible in various languages including English, French, German, Japanese, Portuguese, and Spanish.

- Once you pass the exam, the certification is for life; there are no renewal fees or continuing education necessities.

- Pre-exam procedures involve the purchase of an exam voucher from LPI, with cost varying by location. For instance, in the United States, the price is $120.

- The exam can be scheduled through Pearson VUE and taken either in a testing center or remotely on a personal computer (Windows or Mac only).

- It's recommended to take at least one practice exam and review weak areas before taking the main exam.

- An account on lpi.org is required, which will assign the candidate an LPI ID. This ID is needed to schedule the exam.

- Purchased vouchers are country-specific and expire 12 months from the purchase date.

- Two forms of IDs are necessary for taking the exam, and the names on them should exactly match the exam registration name.

- Arrive 15 minutes before the exam for in-person exams, and for online exams, be available 30 minutes beforehand.

- Personal items, food, or drinks are not allowed during the exam. It is best to just bring IDs and the necessary knowledge for the exam.

In this lesson, you will learn how to:

• Improve Exam Performance: Learn proven strategies to tackle multiple-choice questions effectively.

• Build Confidence: Gain practical tips to reduce test anxiety and approach exams with a clear mind.

• Save Time: Discover techniques to prioritize easier questions and revisit tougher ones later.

• Increase Accuracy: Get insights on avoiding common pitfalls like overthinking or second-guessing.

• Maximize Scoring: Understand how to make educated guesses and ensure no question is left unanswered.

• Preparation Guidance: Learn how to prepare smarter, not harder, through better study habits and practice.

• Practical Question Analysis: Develop skills to interpret tricky wording, handle negatives, and identify key patterns in answer choices.