Introduction to Linux

• Kernel: Drivers for hardware, memory management, filesystems, and task scheduling.
  • Special filesystems to interact with the kernel are /dev, /proc, and /sys.
• User-Space Programs (every program not the kernel).
  • Many were made by the GNU project, hence Linux is sometimes referred to as GNU/Linux.
• Init System: systemd is the first program that runs and schedules all the daemons (programs that run in the background).
• Network Client: We'll use NetworkManager, but there are many other options (including systemd).
• Graphical System: X Windows (the Xorg server implementation). Another more-modern but choice is called Wayland.
• Desktop Environment: On Ubuntu, by default, this is Gnome 3.
  • There are Ubuntu derivatives (Kubuntu, Lubuntu, Xubuntu) whose main difference is having a different default desktop environment.
  • Window Manager: manages drawing windows for programs, often part of a desktop environment.
• Login Manager: gdm, manages logins graphically. It is possible to use Linux without a graphical login.

• The best way to learn Linux is to use it every day.
• Use your Linux computer for everything, even if it is at first less convenient.
• The long-term benefits of having full control of your computer far outweigh any minor inconveniences.
• Remember, a robot is a computer, and you are in the business of controlling robots.
• Every time you fix something on your computer, you are getting better at robotics!

• Sometimes, you need just a quick solution anywhere you can find it. But don't stop there:
  • Find the primary source for the solution and read it.
  • Don't be afraid to read source code to learn how a program works.
• Knowledge gleaned from reading more deeply into problems compounds over time.
  • The more experience you have, the more quickly you can skim manuals to focus on the relevant parts.

• Each day, learn a new keyboard shortcut or command.
• Integrate what you learned into your daily workflow slowly.
• Frequently used commands will soon become second nature.

Everything on Linux can be customized and most parts can be substituted with alternative programs. There are advantages and disadvantages to customizing versus sticking with the defaults.

Advantages

• Make your system works how you want it to work.
• The process of customization helps you learn the system.

Disadvantages

• The farther away from mainstream you go the less help there is.
• Makes it harder to use other people's computers
• Makes it harder for others to use your computer (maybe that's actually an advantage?)

• Use the command line for most every-day tasks.
  • Once it becomes comfortable, you will find it faster, more widely applicable, and easier to explain than other methods.
  • Don't use the graphical file manager. Instead learn to manage files from the command line.
• Ability to use the command line fluently is a crucial skill for a robotics engineer.
  • Many robots don't have a nice GUI interface to work with so there is no choice.
  • Some problems on computers cause graphical displays to malfunction, which means the command line is the only choice.
  • The more frequently you do something, the more it makes sense to learn the command-line version, which is often a first step to automating the task.

• Unless you are doing something specific, the terms console, terminal, shell, and command line

refer to where you enter text commands to the computer and see the output.

1. Easier to automate tasks.
   • If you can accomplish something with a series of commands, you can put the commands into a script to automate them.
2. Faster for certain tasks.
   • For example, rename all files ending in .txt to .md
3. Composability: Can chain an arbitrary number of commands together, feeding the input of one into the output of the other.
4. Easier to explain to others.
   • Commands can be replicated without resorting to screenshots or vague descriptions
   • Commands tend to be more stable than GUI, which seem to change with every update.

1. Easier to use and discover new features.
2. Some tasks may benefit from a mouse.
3. Easier to present information graphically and interactively.

1. Practice by using it every day.
2. Look up how to do tasks via the command line even if you can just use the GUI.
3. Be incremental. Each day, focus on adding a new task or learning a new shortcut or customization.
4. Eventually, you can start trying to simplify tasks that you find tedious or are repeating a lot.
5. Don't be afraid to modify configuration files.

• Program that runs inside the terminal and lets you interact with the operating system.
• Reads your keyboard commands, performs an action, and displays output.
• Usually doubles as an interpreter for a scripting language.
• This is the User Interface (UI) of the command line.

When you first start the shell you are presented with a prompt and are able to type commands.

• The prompt (by default) displays <user>@<hostname>:~$ and then has a cursor where the commands you type are displayed
• Every command occurs in the context of a working directory.
  • By default the prompt shows the current working directory.
  • The ~ symbol expands to /home/<username> and is usually where the shell will start when it is first opened
  • The pwd command (print working directory) displays the path to the current working directory.

1. Tab completion - Press TAB to complete the rest of the command. If there is no unique match press TAB again to view possible matches.
   • There are many options to customize this behavior if you want.
   • When in doubt, press TAB.
   • Usually when TAB does not do what you expect it is because your expectations are incorrect.
2. Bash keeps a history of your commands. Use the up arrow to scroll through previous commands.
3. Reverse search: type part of a command, then press C-r to start searching through your history for a similar command.
4. Bash uses the readline library to enable these keyboard shortcuts and other behavior related to processing your input.
   • readline is also used by other programs and can be customized. See info readline for more details.

Although the internet is useful, your system comes with built-in documentation that is quite thorough. When solving a Linux problem, it often helps to consult this built-in documentation in conjunction with any online instructions that you may find, as a way to understand what you are doing and why it may help. The advantage of using built-in help is that it is the help for the same versions of the software that are installed on your computer.

1. Run the following commands, being sure to press the correct keys/commands to exit each program that may be launched:

   man man
   man --help # comments start with #
   help exit
   bash    # you can start one instance of a shell inside another
   cd /tmp # move to the /tmp directory
   pwd     # print the current directory
   # Use a command to exit the shell you just launched
   # What do you think the current directory is?
   # What command can you use to confirm? Try it.
   

2. Use the up and down arrow keys to get a feel for navigating your history.
3. Type m then press up. What command is shown?
   • Press C-a to move to the start of the line.
   • Press C-e to move to the end of the line.
   • Press C-u to clear the current line.
   • The above keys are the standard emacs navigation shortcuts.
4. Type m then C-r a few times. What happens?

5. Many find C-r cumbersome and prefer using the arrow keys to search through history based on what I've started typing. (So it will find everything beginning with what has been typed). If you want to enable this behavior run the following code to create ~/.inputrc, a configuration file that controls readline:

   echo  '"\e[A":history-search-backward' >> ~/.inputrc
   echo  '"\e[B":history-search-forward' >> ~/.inputrc
   

   Restart bash to apply the changes. If you less ~/.inputrc you should see the lines above are in the file

6. Type m then press up, what command is shown?
   • Clear the current line.
7. Try to rerun the command man man using as few keystrokes as possible. What were they?

• The Virtual File System (VFS) is the primary organizing structure on a Linux system.
• Collections of related data are called files and are stored in the (VFS) as nodes in a tree.
  • Everything on Linux is a file, including hardware devices!
  • Filenames are case sensitive.
  • Although Linux supports using spaces (' ') in file names, I recommend against this practice because the shell requires you to place the file name in quotation marks or escape the space by inserting a backslash \ character (e.g. The\ File\ With\ Spaces).
• The base node of the VFS tree is called the root directory and is referred to as / (slash).
• A directory contains multiple files and other directories.
  • Technically, a directory is a special type of file containing pointers to the elements it contains (everything on Linux is a file).
  • This document treats files and directories separately unless treating a directory as a file is relevant.
  • Every directory contains the directory . (dot), which refers to itself, and .. (dot-dot), which refers to the parent directory (/.. refers to /).
• An absolute path starts with a / and contains a sequence of directories, optionally terminated with a file.
  • For example /home/user, /, /home/user/./../user/file
  • Such a path refers to a specific file or directory, regardless of context.
  • When used at the beginning of a path, the shell expands the ~ (tilde) symbol to /home/username. Thus, paths starting with a ~ are also absolute paths.
• A relative path is a sequence of directory names, optionally terminated with a file, that does not start with a /.
  • For example usr/bin, home/user/.., ./myscript
  • The entity that is referenced by a relative path depends on context.
    • Typically relative paths are relative to the working directory which is the current directory that is active in the shell.
    • The path is resolved by appending the relative path to the path of the working directory.
    • Other programs may use relative paths where the path is relative to some other directory in the system (such as a directory the program uses for configuration).
• Directory structure is standardized according to Linux Filesystem Hierarchy Standard (although not every Linux distribution or program follows this standard perfectly)
  • /bin - basic commands for executing
  • /sbin - tools generally that should only be used by root
  • /lib - shared libraries and kernel modules
  • /usr/bin - files to execute
  • /usr/lib - shared libraries for most programs
  • /etc - global configuration files
  • /tmp - temporary, now adays its in ram and reset everytime reboot
  • /run - temporary runtime data (some things that used to be stored in var)
  • /var - data that programs write, log files, etc
  • /home - user home directory
  • /root - root's home directory
  • /media - automatically mounted filesystems (more about mounting later)
  • /mnt - the area for mount points
  • /sys - access information from the kernel
  • /proc - enables processes and kernel to interact
• Ubuntu and Debian have their own additions to the File System Hierarchy:
  • /snap - used for Ubuntu snaps, not part of the standard.
  • /bin.usr-is-merged /sbin.usr-is-merged, /lib.usr-is-merged:
    • On modern systems /bin, /sbin and /lib point to /usr/bin /usr/sbin and /usr/lib respectively
    • The /{bin,sbin,lib}.usr-is-merged are present on debian-derived systems (like Ubuntu) to indicate that the system has done this

Here are some commands for traversing the VFS from the command line

• pwd - shows the current working directory.
• ls - List files in a directory.
  • By default, ls does not show files that start with a ., causing these files to be hidden.
  • Use ls -a to show hidden files.
  • Use ls -l to show more information about the files.
    • ls | less lets you page through the listing (more on this later).
    • ls b* uses globbing to list all files starting with b (see man 7 glob).
• cd - Change the working directory.
  • cd - Change back to the previous working directory.
  • cd Change to the home directory.

Many commands modify the filesystem structure.

• mkdir creates a new directory.
• rmdir removes a directory (the directory must be empty).
• cp copies a file. Use cp -i to warn you if copying will overwrite an existing file.
• mv move a file, also used for quick renaming.
  • Use mv -i to warn you if moving will overwrite a file.
  • Use mv -n to prevent you from overwriting a file
  • mv can be dangerous: if you move one file over another that file is lost forever.
• rm deletes files permanently (use with caution)
  • rm -r deletes directories recursively (use with extreme caution).
  • rm -rf deletes directories recursively and does not warn if deleting
  • trash (install with sudo apt install trash-cli provides an alternative to rm which will allow you to recover files deleted accidentaly.
• ln Linking (like a shortcut in Windows but better).
  • To create a symbolic link (symlink) use ln -s.
  • This comamand creates a file that points to another file.
  • Opening the symlink is (mostly) equivalent to opening the file it points to.

• Mounts are used to make a set of files appear somewhere in the VFS.
• The data that compose files are physically organized on their storage medium (e.g., a harddrive) by a filesystem such as
  • ext4 The basic journaling filesystem for Linux, and the one your harddrive uses.
  • NTFS (Windows partitions).
  • APFS (macOS).
  • FAT32 (small usb drives or sd cards).
  • exFat (large usb drives or sd cards).
• Filesystems usually reside on a storage device such as a harddrive or CD-ROM.
  • In general these devices on Linux are called block devices.
• A block device can be divided into one or more partitions.
  • Each partition is a section of the device can contain a different filesystem.
• Each block device and each partition is treated as a separate device in Linux and has its own file under /dev.
• Each partition can be mounted to a subdirectory under /.
  • Drivers in the Linux kernel then display the contents of the device as a familiar directory system.
• The /etc/fstab file configures mounts (e.g., mounting your harddrive to / on boot).
• Use lsblk to see the names of devices that can store filesystems.
• Loopback devices (/dev/loop*) enable Linux to mount a file containing a disk image (i.e., a bit-for-bit copy of a filesystem) and pretend it is a physical device.
• These devices are just files!
  • You can read the raw data from them (that is the bytes that make up the filesystem) and write data to them (probably corrupting the disk).
• The mount -t <filesystem> <device> <location> command mounts a device with a given filesystem to a given location.
  • The filesystem can often be omitted as it is automatically detected.
• umount <device|location> unmounts a device or loacation.
• df -h Shows free disk space by device.
• du -h Shows disk space used by individual files or directories.
• By default, Ubuntu automatically mounts devices such as flash drives.
  • You can find these devices under /media/$USER (where $USER is your username).
• In a modern linux system, your desktop environment (e.g., gnome) usually automatically mounts disks when they are attached to your computer (e.g., when inserting a USB flash drive)
  • The mounts appear under /media/<username>

When doing these exercises, use TAB completion as much as possible.

1. Create a hidden directory within your home directory to use as the trash.
   • These notes refer to the directory as trash, but you need to name it so that it is hidden.
2. Using ls, Verify that the directory exists and is hidden.
3. Create a directory /home/$USER/hackathon/ex1 by typing as few characters as possible.
   • Hint: this step can be done with one mkdir command…
4. Change to the root directory / and list the files there.
5. List the files in your home directory without changing your current directory.
6. List the files in /usr/bin.
7. Change your current directory to /usr/bin.
8. List the files in a directory in reverse order.
   • Hint: use the manual for ls and search for the word "reverse" by pressing / in man.
9. Change the working directory to ~/hackathon/ and verify that the working directory has changed.
10. Rename ex1 to example1, using relative paths.
11. Copy a few files from /usr/bin/ to the example1 directory.
12. Move the example1 directory to your trash directly.
13. Create a symlink to your trash directory under ~/hackathon and use it to cd into the trash directory.
    • What is the output of pwd?
    • What is the output of ls ..?
14. Use rm to permanently and irrevocably delete the contents of trash without deleting the the directory itself.
15. Use a command other than rm to delete the trash directory.
16. Use a command to determine the name of file corresponding to the physical device that contains the data for the root file system.
    • What command did you use and what is the name of the device?

• In Linux, everything is a file (including directories and devices).
• Every file is owned by one user and one group.
• Every user belongs to one or more groups.
• Permissions control what operations can be performed on a file, based on the user and the groups that is trying to perform the action
• The file owner controls the file permissions

• whoami retrieves your username
• groups shows what groups you are in
• users shows what users are logged in
• w shows information about logged in users
• id shows the numbers corresponding to users and groups
  • Every user has a unique identifier called a UID
  • Every group has a unique identifier called a GID
• ls -l shows who owns what and the permissions
• chown user:group file Changes the user and group that owns file

There are (mostly) three types of permissions:

• r - read: enables you to view the contents of a file or directory
• w - write: enables you to modify the contents of a file or directory
• x - execute: enables you to run the file or enter into a directory

Permissions apply to users, groups, and everyone else (other).

• Think of these permissions as three bits 000, for read, write, execute.
• Each set of permissions is represented by an octal (base 8) number.
• If a bit is 1 the corresponding permission is allowed, otherwise it is denied.

Use chmod to change permissions on files.

• You can provide an octet to specify all permissions at once:
• chmod 755 file (common permissions for executables, rwxr-xr-x)
• chmod 644 file (universally readable file, only user who owns it can write, rw-r--r-)

Or modify using letter codes for (u)ser (g)roup (o)others, and (a)ll

• chmod a+x
• chmod a-x
• Using letters with chmod is advantageous when you only want to change some permissions while leaving others unmodified
• Using octals with chmod is advantageous when you want to specify all the permissions of the file at one time.

Directories are files. They have owners and permissions too.

• In the output of ls -l, a d in the first permission column indicates that a file is a directory (e.g. drwxr-xr-x)
• To see permissions for a specific directory do ls -l -d1 <dirname>.
  • The -d1 prevents ls from recursively displaying information from sub-directories of <dirname>.

• A symlink is a file that points to another file (called the target).
• The symlink acts as if it were the target file.
• Create a symlink with ln -s TARGET LINK_NAME
• Symlinks have an l in the first column of ls -l output (e.g., lwxrwxrwxr).
  • Symlinks do not have their own permissions. All chmod operations on a symlink happen to the target file.

• root is the all powerful user. root can do anything. Be careful when you run with root permissions.
  • By default, root can read and write to any file in the system, regardless of ownership or permissions
  • root can change ownership of any file, and become any user without needing a password.
  • root cannot execute files that do not have the execute permission. However, root can always set this permission bit.
• sudo lets you temporarily execute commands as root by entering your own user password.
  • This command lets you administer your system without directly becoming root.
  • The root user controls which users have access to sudo.
• su lets you change to a different user. By default that user is root, but you will need the root password.
  • On Ubuntu, you do not know the root password. (This is a choice that Ubuntu has made; other distributions work differently).
  • You can use sudo to set a root password if you want (arguably this is less secure and not a good idea).

1. What are the permissions for /usr/bin/ls?
2. What are the permissions of your home directory?
3. Create a new file. What are its permissions?
4. Remove the write permission from the file you just created and try to modify it. What happens?
5. Create a new directory and a file in that directory. Remove the execute permission. What happens when you try to cd into it?
6. Remove the read permission from the directory. What happens when you ls the directory?
7. Restore the execute permission and try to cd into the directory. What happens?
8. Set permissions so that you can list the files in the directory, cd into it, but not add or remove files from it.
9. Determine the permission octets for the following common permissions:
   1. rwxr-xr-x (usually used for scripts)
   2. rw-r-r (A file you want to share with others but only you modify it)
   3. rw-rw-rw (Everyone can read and write the file

• The basic unit of execution on Linux is called a process. Most programs that you run consist of a single process but a few (such as firefox) consist of multiple coordinated processes.
• Each process has a unique process identifier (PID), that can be used to interact with it.
• You can launch processes from the command line: in fact when you ran many of the commands in the previous section you were actually causing the Linux kernel to load and execute a process.
• Process are organized hierarchically into a tree structure. Process on Linux can spawn child processes. By default the processes you run from the shell are child processes of the shell (and so the shell is their parent process). When the parent processes terminates its children also stop running.
• Processes can also be launched as daemons. These are background processes not associated with a shell and will continue running even when the shell exits.
• For example, when you run ls, this command launches a process that lists files and then terminates.
• The shell, bash, is also a process. Some shell-builtins, are a part of bash and don't launch separate processes (such as cd).

• ps reports information about processes.
  • ps by default shows processes run from your current shell.
  • ps aux shows all processes by all users regardless of whether they are associated with a shell.
    • The a adds processes from all users not just your user.
    • The u prints the username and some other information next to the processes.
    • The x adds processes not associated with the shell.
• pstree shows the process tree.
  • If process A launches process B then A is the parent of B and B is the child of A.
• top provides interactive process monitoring in the terminal. It includes CPU and memory usage reports.
• htop (install with sudo apt install htop) is a fancier version of top with an easier-to-interpret display and easier to use interface.
• free -h Shows the amount of free RAM and swap memory used by the processes on your system in a human readable format
• pgrep search for processes that meet certain criteria (such as name).

• The user can communicate with processes using signals.
• Each signal invokes a different behavior (see man 7 signals)
  • Each signal has a name and a number (the number depends on processor architecture)
  • Four important signals are:
    1. SIGKILL Tell the process to close.
    2. SIGSTP Tell the process to stop executing code but remain in memory.
    3. SIGCONT Tell the process to resume.
    4. SIGQUIT Tell the process to terminate immediately.
• kill sends a signal to a process with a given PID.
  • kill -KILL 1435 will send SIGKILL to PID 1435.
  • kill -9 1435 will also send SIGKILL to PID 1435, since (on x86) 9 is the number for SIGKILL.
• pkill sends a signals to processes matching a certain criteria.
  • You probably want to pgrep before pkill to see what it's going to do.
• killall sends a signals to processes that exactly match a given name.

Jobs are processes that you run from the shell. The shell keeps track of these processes and helps you manage the, which is often more convenient than managing processes based on PIDs. As jobs are a shell-specific concept, this information primarily pertains to bash (although other shells have similar functionality).

Normally, when you run a command, it starts the process in the foreground. The shell will not offer a prompt to read new keyboard input until the process terminates.

You can also start a process in the background by appending an ampersand & to the command (e.g. command &). The shell prints the job number and PID of the process for your reference and then provides another prompt, letting you continue running commands as the process you started runs.

Here are some commands and keyboard sequences that relate to jobs. Jobs are the primary way that a user can run multiple programs simultaneously from a single shell.

• jobs lists the jobs. Each job has a number. The first job is 1 and they increment. Refer to the job as %NUMBER (e.g., %1) in commands
• Pressing C-c will send SIGKILL to the current foreground process, which should cleanup and terminate.
• Pressing C-\ will send SIGQUIT to the current foreground process and tell it to terminate immediately (use sparingly. processes can sometimes ignore SIGKILL but in most circumstances SIGQUIT will get through, however the process will forego some cleanup routines).
• Pressing C-z will send SIGSTP to the current foreground process, which will suspend it (it remains in RAM but does not run).
• bg %<JOB> will resume <JOB> in the background (e.g., bg %1).
• fg %<JOB> will bring <JOB> into the foreground and resume it if it had been suspended.
• disown %<JOB> will detach the job from the shell (so it will not be terminated when the shell closes).
• You can also use %<JOB> with kill to send a signal to the specified job.

1. Run gedit from the terminal (sudo apt install gedit to install). Note that you cannot run more commands in terminal until gedit exits.
2. Suspend the process with C-z. What happens to gedit?
3. Use jobs to see the processes you have started in the shell.
4. Resume gedit in the background. What happens to gedit?
5. Bring gedit to the foreground.
6. Quit gedit by typing the appropriate keys in the terminal.
7. Launch gedit directly in the background.
8. Close gedit with one command from the terminal.
9. Run gedit in the background again, then exit the shell by closing the terminal window.
10. Run gedit in the background again, then exit the shell by typing exit

1. The main package management tool on Ubuntu is apt.
2. You will see references to apt-get everywhere: this command still works but is an older tool.
   • apt provides a mostly compatible but nicer interface to apt-get.
   • For example, by default apt includes status bars and other information that is useful.
   • apt-get still works if you want to use it and is preferred for scripts.
3. Any apt command that will change your system must be run as root (i.e, use sudo).
4. The --dry-run option lets you see what apt will do without actually doing it.
   • Be careful, as you can seriously destroy your system with apt, especially if you start using exotic flags.
   • Linux distributions like Guix and NixOS are designed around package managers that let you deterministically roll-back changes and were developed partially as a reaction to problems you can run into with traditional package managers like apt.

The init system controls what happens when you start your computer and what tasks run in the background.

1. Systemd is responsible for running tasks automatically when your computer starts.
2. It also does a lot more (such as logging with journald).
3. Use systemctl to control daemons (background processes) running on your computer.
4. systemctl start <service> starts a service.
5. systemctl stop <service> stops a service.
6. systemctl enable <service> makes the service run during the boot process.
7. systemctl disable <service> prevents the service from running during the boot process.
8. systemctl reboot [--firmware-setup] will reboot your computer (--firmware-setup enters the UEFI screen on reboot).
9. systemctl poweroff will turn off your computer.
10. systemctl isolate <stage> switches to a different run level (e.g., single-user, multi-user, graphical.
11. systemd also has timers, which can run a task at a given time (like chrontab).
12. systemd --user <command> lets you start tasks as an ordinary user.

1. Examining log files is one of the first steps to take when something goes wrong.
2. If you are unsure of something and are asking someone for help, it often makes sense to show them log information.
3. Logs are stored in /var/log.
4. dmesg shows logs related to the kernel.
5. Systemd has a built-in logging system called journald.
6. journalctl -u <service> returns log entries for the given service.
7. journalctl -x shows extra explanatory information which can be helpful.
8. You can use journalctl to view other types of logs as well, see man journalctl.

• Environment variables store information that can be accessed by processes.
• Environment variables can be local to the process or marked for export, which makes them inherited by the child process.
• printenv displays all currently defined variables.
• printenv VARNAME displays the value of VARNAME.
• echo $var prints the value of var (echo generally prints data to the screen).
• env displays the currently defined variables and does other things.
• To set environment variables in bash.
  • VARNAME=value sets the value within the shell but processes launched from the shell won't see it.
  • export VARNAME to make the variable visible to processes launched from the shell.
  • export VARNAME=value sets the variable and exports it.
  • VARNAME=val runprogram exports the variable to the program run on that line but the value is cleared afterwards.
  • unset VARNAME clears the environment variable.
• To access the value of an environment variable prefix it with a $.
  • By default, the value of the variable is substituted wherever you write $var.
  • You can also use the syntax ${var}, which can separate var from subsequent characters.
  • You can use \$ to get a literal dollar sign.
  • Single quotes ('') also suppress a variable substitution.
• Command substitution: $(command) will be replaced with the output from command. Therefore you can capture a command output in a variable by doing var=$(command), e.g., var=$(echo "hello"), var will hold "hello".

Dotfiles refer to the hidden files that programs place in your home directory and (more recently) under ~/.config. These files contain user-specific configuration for most programs on Linux, whereas global configuration is stored in /etc. Using dotfiles, you can customize most aspects of your system.

1. Print the value of the HOME environment variable.
2. cd uses the value of HOME to determine where to go when no arguments are provided.
   1. Using the HOME environment variable, and without passing any arguments to cd, use a single command to change your directory to /usr/bin
   2. cd back to your home directory.
3. Display your path.
4. Save PATH by running export opath=$PATH.
5. Display your path.
6. Copy /usr/bin/free to your home directory.
7. Run free. Which free are you using? (The one installed on the system or the one in your home directory?)
8. Append your home directory to PATH. Run free. Which free are you using now?
9. Clear PATH so that it is empty.
   • Verify that it is empty using echo.
   • Try running free. What happens? Why?
   • Try running ls. What happens? Why?
   • Run the free in your home directory by specifying the relative path to it.
   • Run the free in /usr/bin by specifying the full path to it
   • Move ~/free to /tmp (since /tmp is stored in RAM this copy will be deleted on your next reboot.
   • Restore the PATH (export PATH=$opath) and verify that ls works
   • Bonus: Why did echo work and ls did not when you unset the PATH? Hint: use the type command to find out.
10. Install a package with apt. Some programs you may wish to install:
    • Picture editing gimp (Free Photoshop), inkscape (Free Adobe Illustrator), imagemagick (Command line image manipulation).
    • mplayer (Media Player), vlc (media player), ffmpeg (Basically do anything with video files, but from the command line.
    • ripgrep, a utility for a full-text search of files via the command-line.
11. View what you have done using apt by examining the apt log file. less /var/log/apt/term.log.

Streams, pipes, and redirects constitute the plumbing of bash and enable you easily change the input source, output destination of programs and chain together programs. The Unix philosophy is to have many programs that do one thing well and allow the user to chain these programs together.

Bash scripts contain sequences of commands and instructions for the bash shell to run. A bash script can be a simple list of commands executed in sequence or a complicated and messy program.

Overall, bash is useful for quickly automating tasks that require running commands in the bash shell. For more complicated tasks it is often easier to maintain a python script.

1. Modern bash scripts usually start with #!/usr/bin/env bash (sometimes you will see #!/usr/bin/bash).
   • After creating a script you will usually chmod 755 your_script to make it executable.
   • If your script has the executable permission and this shebang line then you will be able to execute the script directly by either having it on your PATH or explicitly typing the path to the script at the prompt.
   • Comments in bash start with # so the shebang line is ignored by the interpreter.
2. Alternatively, scripts can omit the shebang, and then only be executed by explicitly calling bash directly on the script.
3. For an in-depth tutorial see The Linux Documentation Project Advanced Shell Scripting

Even a broken clock is right twice a day.

• The file /dev/urandom is an infinite stream of random bytes.
• tr lets you delete bytes matching certain criteria from an input stream.
• fold cuts off an input stream after a certain width and inserts a newline.
• date prints the current date and time: arguments provide the format.
• grep searches for strings from stdin.

Using ONLY the above commands, stream redirection, pipes, and command substitution $() write a single line that will generate random times in the format HH:MM and print out the time if the randomly generated time matches the current time to the hour and minute (as generated by date when you press enter).

You may wish to experiment with various parts of the pipeline to put this all together.

The network can be thought of in terms of different layers, according to the OSI model. What follows is a simplified conceptual description, useful for someone who is specializing in robotics.

Hubs and switches are devices that enable multiple computers to communicate on a network.

1. A hub is essentially a wire-splitter: when a device connected to a hub sends data, all the other devices on the hub receive data.
   • If the data is destined for a specific MAC address, the other computers on the hub ignore it (or can inspect it if they want).
2. A switch operates using MAC addresses. If a computer sends data to a given MAC address, the switch intervenes and sends that data only to the intended recipient.
   • These days, we are mostly connected to switches rather than hubs.
3. Generally, all computers connected to the same switch or hub can be thought of as being on the same Local Area Network (LAN).
4. A router generally contains a switch, along with an extra port for a Wide Area Network (WAN).
   • The devices on the switch are part of a LAN
   • The router lets them communicate to an upstream computer via the WAN port.

In a TCP/IP network (like the internet), every computer has an IP address. This address is used to route packets (containing data) to your computer. For IPv4 addresses this is a 32 bit number, often written as 4 decimal numbers separated by periods (e.g., 192.168.1.3).¹

1. ssh or Secure Shell lets you run a shell on a remote computer. All data is encrypted, hence the "secure".
   • Essentially this is remote desktop minus the desktop
   • You can also use ssh to get graphical applications running over the network, either directly or by using vnc or x2go
2. You will mostly be using ssh clients, but if you do run your own ssh server, I recommend carefully considering the security consequences (since doing this lets remote users run commands on your computer).
   • Running ssh on a non-default port certainly provides some security by obscurity.
3. I will provided everyone with shell accounts on our GPU machine (address provided separately) which you can use to practice your ssh skills.
4. You can copy files using scp or rsync

1. The hostname of your computer is the name of the computer used by others on the network.
2. In the terminal you will see a prompt of the form <user>@<hostname>.
   • <user> is your username.
   • hostname is the name of your computer
3. You can change your hostname with hostnamectl set-hostname <new-hostname>
   • Don't include the angle brackets (<>): e.g., hostnamectl set-hostname northwestern will set your hostname to northwestern.
   • The hostname must start with a letter, and contain only lowercase letters (a-z), digits (0-9), and the hyphen character (-).
   • Hostnames are technically case-insensitive, but conventionally use lowercase letters.
   • Keep the hostname to less than 8 characters or so.
   • An official guide to choosing a "good" name for your computer is available in RFC 1178.
4. The file /etc/hosts- enables you to create a static mapping between names and IP addresses.
   • Some Linux functionality requires <myhostname> to properly resolve to your local machine.
   • Because <myhostname> is generally not registered with the Domain Name System (DNS), by default it cannot be translated into an IP address.
   • The entries in /etc/hosts enable your system to resolve <myhostname> and <myhostname>.localdomain to 127.0.1.1, which always points to your computer.
     • Commonly 127.0.0.1 is used to point to your local machine, but technically any 127.xxx.xxx.xxx addresses also work.
     • Using 127.0.1.1 enables distinguishing between addresses resolved through the name localhost (which always points to the local machine) and those resolved through <myhostname> (which if you set it up can point to the ip address for your computer as used by others on the network).
     • For details see Stack Overflow and the Debian Manual.

We will prepare to get you accounts on a machine that you can ssh into.

1. Trace your route to a website of your choice.
   • Can you identify any of the hops (e.g., which one is your router)?
   • How many hops until the packets leave your LAN?
2. I've created a student account that you can use
   • Download the private ssh key and save it as ~/.ssh/id_student curl -L 'http://beast.mech.northwestern.edu/id_student' > ~/.ssh/id_student
   • Change permissions to owner read-write only: chmod 600 ~/.ssh/id_student
   • Connect to the server ssh -i ~/.ssh/id_student student@beast.mech.northwestern.edu
   • When you've successfully connected, disconnect
3. On your LOCAL computer: create your own ssh key ssh-keygen -t ed25519
   • Set a password!
   • Creates private key ~/.ssh/id_ed25519 (don't share this with anybody ever) and public key ~/.ssh/id_ed25519.pub
4. Use scp to copy your public key to the server scp -i ~/.ssh/id_student ~/.ssh/id_ed25519.pub student@beast.mech.northwestern.edu:/home/student/<firstname_lastname>.pub
   • <lastname_firstname> should be your last name, underscore, your first name
5. Once your key is uploaded, I will eventually add it to your username's authorized keys file ~/.ssh/authorized_keys on our GPU computers.

1. X Windows - Client server architecture for drawing GUI's and handling input.
   • Today Xorg is the display server.
2. Wayland - The successor to X Windows, available on Ubuntu, recently used as the default
3. Display Manager - This is the graphical screen when you login. GDM is the gnome display manager.
4. Desktop Environment - This is GNOME 3 by default, provides the user interface for interacting with the system
   • Alternatives include KDE and XFCE
5. Window Manager - Draws windows on screen. Your window manager is integrated with Gnome 3.
6. On Linux, you can choose your own Desktop Environment, Window Manager, and Display Manager. It is also not necessary to have any of them.

1. Whatever text you highlight goes into a clipboard. Middle click pastes.
2. You can also copy and paste with right click. This is separate from the middle click clipboard
3. C-c and C-v work in many gui programs but not the terminal. Adding Shift to these combinations works in some terminals
4. You can paste using Shift-Ins, using readline commands (emacs style).
5. Emacs and vim use their own clipboards but can access the X clipboard.