Frontendmasters - Complete Intro to Linux and the Command-Line (2020)

Command-line skills are essential for modern developers. Linux has become the backbone of modern computing, and most developers today rely on tools built on the command-line, no matter if you're on Mac, Windows, or Linux! In this course, you will learn powerful commands, use Ubuntu, quit VIM, handle package management, and write your own shell scripts.

Table of Contents
Introduction

Introduction
00:00:00 - 00:07:40
Introduction
Brian Holt gives an overview of the course, adds that the course focuses mainly on the CLI, and explains why developers need a good understanding of the CLI.
What is Unix
00:07:41 - 00:12:47
What is Unix
Brian gives an overview of the history of the Unix operating system, including its creation at Bell Labs, and adds that the Unix philosophy and guiding principles are still applied today by software engineers.
What is Linux
00:12:48 - 00:22:34
What is Linux
Brian explains that Linus Torvalds created Linux using the Unix codebase and made Linux free and open source, gives a high level overview of the Linux Kernel, and explains the difference between Linux and Linux distros.
How to Run Linux
00:22:35 - 00:31:09
How to Run Linux
Brian describes what virtualization is, and explains how to get Linux running on Windows 10 and macOS operating systems with either VirtualBox or Multipass. Virtualization gives engineers the capability of running multiple operating systems and applications on a single computer or server.

The CLI

Anatomy of the Command Line Interface
00:31:10 - 00:43:32
Anatomy of the Command Line Interface
Brian explains that within a terminal, there is a command line, which has a REPL, or Read Evaluate Print Loop, that allows engineers to only write one line of code at a time. The difference between a shell and an emulator is also discussed in this section.
CLI Directories & Arguments
00:43:33 - 00:48:27
CLI Directories & Arguments
Brian demonstrates how to navigate through the different directories within a machine, and explains that arguments or parameters are similar and used to navigate within the CLI.
Flags
00:48:28 - 01:01:18
Flags
Brian demonstrates how to use flags on the command line, and explains that similarly to arguments, flags are information that can are used in CLI commands.
CLI Search
01:01:19 - 01:11:46
CLI Search
Brian gives an overview of best practices for searching for a command, a program, a directory, the bash history, or a document on the command line.
Bash History
01:11:47 - 01:19:11
Bash History
Brian continues to explore the command line interface by demonstrating how to find the history of bash commands that have been used. Useful interactions like clearing, copying and pasting, and repeating the last command are also discussed in this section.
CLI Shortcuts
01:19:12 - 01:23:07
CLI Shortcuts
Brian demonstrates shortcuts using the CTRL key within the CLI useful for developers every day.
Signals
01:23:08 - 01:32:38
Signals
Brian explains that signals are notifications that are sent to programs from the command line, and gives examples of signals such as CTRL + D -SIG, a signal used in the command line to signal the end of the use of a program. SIGTERM and SIGKILL are also discussed in this section.

Editors

nano
01:32:39 - 01:40:58
nano
Brian gives an overview of text editors already available within the command line, and starts with nano, one of the most common and available options.
VIM: A Brief History
01:40:59 - 01:47:54
VIM: A Brief History
Brian gives a brief history of VIM, an editor within the CLI, explains how VIM builds off of previous editors.
VIM: Basic Commands
01:47:55 - 01:55:01
VIM: Basic Commands
Brian reviews basic VIM commands, including starting VIM, editing a file, and saving a file. Also covered is how to quit VIM, which is the only command worth remembering, according to Brian.

Files, Pipes, & Permissions

Reading Files
01:55:02 - 02:06:51
Reading Files
Brian gives an overview of the commands on the CLI that allow developers to read a file, to create one or multiple files, to learn more about a specific program, or to view a snapshot of a given file.
Creating & Moving Files
02:06:52 - 02:21:12
Creating & Moving Files
Brian demonstrates how to create a file from the command line, how to check that the new file was created, how to delete a file, how to rename a file, how to compress a file, and how to delete a folder. Exercising caution when using the delete or 'rm' functionality is also discussed.
Wildcards & Replacements
02:21:13 - 02:31:06
Wildcards & Replacements
Brian explores wildcards, expansions, and replacement, and explains how and why they fixtures in a developer's toolkit.
Output Streams
02:31:07 - 02:40:28
Output Streams
Brian explains that one of the Linux philosophies is the assumption that the output of a program can be the input to another program through streams and pipes, demonstrates how to redirect the output to another file. This section focuses mainly on 'stdout' and 'stderr'.
Input Streams
02:40:29 - 02:45:49
Input Streams
Brian explains that stdin (pronounced standard in) is used for input streams using the 'cat' command to input the text of one file into another.
Pipes
02:45:50 - 02:55:06
Pipes
Brian explains that in order to move from one program to another within the command line, developers have to use pipes. A few commands that allow users to remove multiple files or find multiple files with common characteristics are also explored in this segment.
Principle of Least Power
02:55:07 - 03:02:17
Principle of Least Power
Brian explores the Linux security and permissions model, which is centered around the concepts of users, privileged and unprivileged roles, and the permission model.
Superuser
03:02:18 - 03:13:23
Superuser
Brian demonstrates how superuser commands grant access to the root user role, and explains best practice to create other users.
Group Permissions
03:13:24 - 03:26:20
Group Permissions
Brian explores group permissions by changing the ownership of various files, and demonstrates what commands to use for each type of permission change.
Permission Shortcuts
03:26:21 - 03:34:00
Permission Shortcuts
Brian gives an overview of a few numbers used to change permissions such as read, write, or execute through the terminal.

Environments & Processes

Environments
03:34:01 - 03:43:45
Environments
Brian explains that environment variables are already set in Bash, and demonstrates how to add new environment variables using .bashrc.
Processes
03:43:46 - 03:53:34
Processes
Brian defines a process as any sort of command that is currently running, for instance, running bash from the terminal. Interacting with processes is also explained, as well as why they are important.
Exit Codes & Process Operators
03:53:35 - 04:00:55
Exit Codes & Process Operators
Brian explains how to run a sequence of commands and subcommands as well as exit codes using exit codes, and process operators. Operators allow engineers to run a task once another task has been completed.
Subcommands
04:00:56 - 04:07:39
Subcommands
Brian explains that when invoking a command within another command, that command is called a subcommand, and runs a few subcommands as examples

Networking & the Internet

SSH & Secondary Machine
04:07:40 - 04:12:39
SSH & Secondary Machine
Brian explains that SSH allows the creation of an intranet, and demonstrates how to create a secondary virtual machine.
Linking two Machines with SSH
04:12:40 - 04:26:24
Linking two Machines with SSH
Brian creates an SSH key in the primary machine and links the secondary machine to the primary machine using a public key. Linking two virtual machines is the simplified version of what various cloud companies offer as a main service.
SFTP
04:26:25 - 04:34:27
SFTP
Brian explains that it is possible to transfer files using an SFTP connection with an SSH key, and demonstrates how to securely transfer files between a remote machine and a local one.
Wget
04:34:28 - 04:41:56
Wget
Brian explains that wget is the network version of cp or copy, adds that wget allows developers to interact with downloads, and that wget allows recursive downloads.
curl Basics
04:41:57 - 04:48:07
curl Basics
Brian explains that 'curl' is a Linux program that allows developers to test against API servers, starts running an API server locally and uses curl to hit the API endpoint.
curl & HTTP Verbs
04:48:08 - 05:04:11
curl & HTTP Verbs
Brian explores the various HTTP verbs used with 'curl' commands, and demonstrates how to copy a network request. The use of headers and cookies with the curl program is also discussed in this section.

Package Management

Package Management & APT Basics
05:04:12 - 05:17:44
Package Management & APT Basics
Brian gives a brief overview of package management, focuses on the package management tool (APT), and reviews commands.
APT Q&A
05:17:45 - 05:21:56
APT Q&A
Brian answers questions from the audience about the different APT commands, namely what are the differences between apt upgrade and apt update.
Snaps
05:21:57 - 05:35:29
Snaps
Brian explains that snaps are a new format for installing dependencies, and adds that snaps are useful for developers because they are more secure and update automatically.

Shell Scripts

Writing Scripts
05:35:30 - 05:40:03
Writing Scripts
Brian explains that developers can create shell scripts with bash to automate a task, and demonstrates how to create, build, and run a shell script.
Hashbang
05:40:04 - 05:44:47
Hashbang
Brian explains that hashbang, prounounced "shabang" is a line that starts with the characters '#'! in a Bash script and that indicates how the bash file should run. For instance, the hashbang can indicate in what language a file should be interpreted. This section also includes a demonstration of how to add a hashbang is a script.
Path & Variables
05:44:48 - 05:53:22
Path & Variables
Brian demonstrates how to create paths to Bash scripts to simplify running scripts through the terminal without having to be in a specific directory. Then, best practices to add variables to a bash script and allow the script to access a variable are outlined.
Arguments
05:53:23 - 05:56:43
Arguments
Brian demonstrates how to pass in the path to a given directory and how to move documents to that directory using arguments.
Conditionals: If Statements & Tests
05:56:44 - 06:04:15
Conditionals: If Statements & Tests
Brian explains that control flows can be used in Bash scripts, and adds that if statements are syntax sugar for tests in bash. In other words, every if statement written in a Bash file is a disguised test.
Conditionals: Else, Else If & Case Statement
06:04:16 - 06:12:37
Conditionals: Else, Else If & Case Statement
Brian continues exploring bash script by live coding scripts with 'else' and 'case' statements, and live coding another script that contains case statements. The tools introduced are designed to give viewers the basic tools to write more sophisticated bash scripts
Loops & Arrays
06:12:38 - 06:23:45
Loops & Arrays
Brian continues adding complexity to the bash script started in the previous segment by demonstrating how to use loops and arrays.

Automation & Customization

cron
06:23:46 - 06:36:08
cron
Brian explains that developers use the cron command when a specific job or program needs to be executed following a schedule, and demonstrates how to build a cron job.
Customize Your Shell
06:36:09 - 06:41:59
Customize Your Shell
Brian explains that the prompt is the bit that shows up on every new line, and demonstrate how to customize it.
Colors & Awesome Bash
06:42:00 - 06:45:19
Colors & Awesome Bash
Brian continues to demonstrate how to customize the prompt by adding new colors and recommends the use of Awesome Bash to take the prompt customization a step further.

Wrapping Up

Wrapping Up
06:45:20 - 06:50:08
Wrapping Up
Brian thanks the audience, and shares some suggestions about what to focus on next in the learning journey.

also You can find my other helpful Programming-posts
(if old file-links don't show activity, try copy-paste them to the address bar)