Skip to main content Link Menu Expand (external link) Document Search Copy Copied
Notes

CSE 391

Lecture 1 - June 20

  • Need 14/18 points to pass
  • SSH basics: username@server
  • Unix: developed in the late 60s at Bell Labs
    • Everything is a file!
  • Linux: developed in 1992 by Linus
  • Why use the CLI? It is often faster and easier!
  • /bin is where the binaries are stored
  • ls -lh lists everything in human-readable format
  • We can use the find command to find files!
    • Starts in your current directory, recursivly searches from there
    • -name matches the end of each path
  • man: manual for commands

Lecture 2 - June 27

  • Shell expands all * wildcards
  • cat: concatenate a file to the terminal
  • less: allows easy viewing of text vim-like
  • head: print the first lines of a file
  • tail: print the last lines of a file
    • -f flag to keep running file
  • wc: word count program
    • by default, counts lines, words, then characters
  • sort: sorts lines alphabetically
  • uniq collapses adjacent unique lines
    • Typically should sort it first
  • grep: search tool for files
    • First argument is search term, proceding arguments are files to search from
    • Prints each line that matches the search term
  • Running java on the command line:
    • javac ProgramName.java combiles the program
    • javac ProgramName runs the program
    • java ProgramName.java compiles and runs the program
  • Streams:
    • Standard input: stdin
    • Standard output: stdout
    • Standard error: stderr
  • Reads or adds to the stream however much is requested
  • Use the right waka > to redirect standard output to a file
    • Double waka >> appends standard output to a file
  • Use the left waka < to redirect standard input from a file
  • Use two waka 2> to redirect standard error to a file
  • Pipes |: takes standard output of what’s on the left and uses it as standard input on the right
    • Used to chain commands together
  • ctrl-D to close a program

Lecture 3 - July 4

  • command1 && command2 runs command2 if command1 ran successfully
    • Similar to short-circuting evaluations
  • command1 || command2 runs command2 if command1 didn’t run successfully
  • command1 ; command2 always runs both commands
  • Some commands don’t read from standard input if none are provided
    • xargs: “negotiate” between standard input and passing parameters
    • Command substitution: evaluate what’s in a $(eval) and substitute
  • Append &1 to use the same as standard output (not as confident)
  • tee saves standard output to a file while still printing it out
  • echo echos what is passed
  • cut: cuts up input:
    • -cRANGE outputs the RANGE of characters
    • -dDELIMETER cuts at the delimeter
    • -fRANGE outputs the RANGE of fields
  • Standard output and input is buffered, use stdbuf to change behavior

Lecture 4 - July 11

  • A repo stores the state (and history) of the project
    • Don’t store the compiled files, build somewhere else
  • Using a remote repository allows us to have a unified source of truth
  • git status: display the status of the repo
    • Only working directory and staging area
  • git commit -m "message": commits the staged files with the message
  • The four stages of git:
    1. Working directory: the local files on your computer
    2. Staging area/idex: changes I’m preparing to commit
    3. Local repository: project changes on my computer
    4. Remote repository: shared and source of truth
  • git add to add files
  • git log to view past commits
    • Each commit gets its own hash
    • Use --decorate --all --graph to get a visual history of the repository
  • origin master is where the computer thinks the remote repository is at
  • HEAD is where we are locally
  • git restore file to remove local changes
    • Add --staged flag to un-stage
  • The diffs for files are what is actually tracked, that means a file can be both staged and have unstaged diffs
  • git diff allows us to view differences between working directory and staging area
    • Add --staged flag to view diff between staging area and local repository
  • git help command displays the man page for git command
  • git commit (no -m) allows you to add a commit message on first line, then other info on other lines
  • git pull “pulls” the remote commits to your local repository
    • Often leads to a “merge commit”
  • git switch -c name to create a branch and switch to it
  • HEAD is most recent commit, HEAD~n is the commit n before HEAD

Lecture 5 - July 18

  • master or main is the “single source of truth”, the history of the project
    • The code on master should be stable
  • Continuous integration (CI): when you push, automated tests verifty it is stable
  • Each commit references its parent, somewhat like a linked list
  • Branches are pointers referencing commits
    • master is the default one
  • HEAD is the current pointer, where the user is at
    • We can move this to whichever branch we want
  • Use git log --graph --oneline for a simplified version
  • To create a new branch, we use git branch <branch_name>
    • The branch is created pointing to wherever HEAD is
  • To switch branches, we use git checkout <branch_name>
    • HEAD now points to <branch_name>
  • git merge <merge_name> merges <merge_name> into current branch HEAD
    • Attemps to auto-merge but runs into conflicts when conflicting diffs
      • Changes the file to show the conflicting diffs, must be resolved
      • To resolve it, we commit like normal
      • git status will now give more information on error
  • After merging <branch_name>, you can checkout <branch_name> and git merge master to fast-forward to the merge
    • Fast-forward is like moving HEAD to the other branch’s reference (as it is acting like a linked list)
  • We save the pointers (branches) from our remote (origin) repository as well
    • That’s what origin/master are
  • git fetch fetches information from the remote repository
  • git pull is (roughly) git fetch and git merge in one command
  • Merging in practice:
    1. Create a local branch and make some commits
    2. Push those commits to remote
    3. Open a merge request on GitHub/GitLab
    4. Collaborate with others, leave comments, fix conflicts
    5. Merge into master (or other branch)
  • Much of the time you can’t push directy to master
  • git checkout -b <branch_name> creates a new branch <branch_name> and swtiches to it
  • When there is a merge conflict in a merge request, (in GitLab) you can make a reconciliation commit in browser
  • Finally, you can make the merge commit in the browser
  • Use git branch -d <branch_name> to remove a branch
  • Use git init to initialize a git repository
  • HEAD is the head of the “linked list” that represents the repository
  • A tag is a fixed reference pointing to a specific tag
  • A branch is like a tag, but moves as HEAD moves
    • Use git tag <tag_name> to tag a commit (by default HEAD)
  • A “deatched head” is a git repository where no branch is associated with it
    • Can happen when checking out something that doesn’t have a branch at it
    • This can happen when checking out a tag
  • git rebase is useful to apply a o

Lecture 6 - July 25

  • A regular expression (regex) is a description of a pattern of text
  • This is a common way to search for text
  • grep: global regular expression print
    • By default, case sensitive: use -i to ignore case
    • Passing -E to grep allows us to use regular expressions
  • . matches any character
  • Use backslash \ to escape (some?) special characters
  • ^ matches the beginning of the line
  • $ matches the end of the line
  • “Words” are things that are separated by some amount of whitespace
  • \< refers to the start of a word
  • \> refers to the end of a word
  • pattern1|patttern2 searches for pattern1 or pattern2
  • () groups expressions together
  • x* matches any number of xs
  • x+ matches one or more xs
  • x? matches zero or one x
  • [xyz] is equivalant to (x|y|z)
    • It also makes all characters in the brackets to literals
  • [a-z], [A-Z], [0-9], and [a-zA-Z] all work as expected
  • x{5} matches x five times in a row
  • x{,5} matches x up to five times in a row
  • x{2-5} and x{5,} work as expected
  • [^0-9] matches any character that is not [0-9]
  • Backreferences allow for capturing and referring to previous patterns
    • (..)\1 matches any two-character pattern which is repeated

Lecture 7 - August 1

  • sed -r 's/REGEX/TEXT does search and replace for text
    • Append with a file name to run it on the file
    • Use the -i.EXTENSION flag to change the file and use the EXTENSION
  • By default, sed replaces only the first match on each line
    • To replace with all matches on each line, append with g: sed -r 's/REGEX/TEXT/g
  • To use the forward slash, we need to escape it: \/
  • We can use backreferences in the TEXT

Lecture 8 - August 8

  • whoami prints out your username
  • users prints out all currently logged in users
    • pinky is like users but more informative
  • groups prints all the groups that you belong to
  • ps prints all the processes you’re currently running
    • -u uname does that for a username
  • top or htop shows system usage with procceses
  • kill PID kills the process with PID PID
  • /usr/bin holds many of the executable binaries
    • /usr stands for universal system resouces
  • sudo: super user do
  • .bash_profile is run every time you login
  • .bashrc is run for every non-login shell
  • To make an alias: alias new_name="command to be ran"
    • alias alone will print all aliases
  • $PATH is all of the paths that your system will search through for a command
    • Each path is separated by a : delimiter
  • File permissions: drwxrwxrwx
    • If there is a character in a slot, it means that it has that permission
    • First character represents if it is a directory
    • Each following set of three represent if there are read, write, or execute permissions
      • Those sets are owner (u), groups (g), and others (o)
    • Owners of a file can always change the file permissions
  • To change permsissions, use the chomod command
    • Use chmod T+P where T is the type of user and P is the permission type
    • chmod T-P takes away permissions
    • Octal codes allow simple ways to type out permissions for a user type
      • +4 for read, +2 for write, +1 for execute
  • Directory permissions:
    • Read: if the person view the directory
    • Write: if the person write to the directory
    • Execute: if the person enter into the directory
  • umask sets default permissions for new files

Lecture 9 - August 15

  • The first line of a shell script should be the “shebang”, #!/bin/bash
    • The first line of a Python script should be #!/bin/python
  • Bash scripts are simply shell commands, executed line-by-line
  • Shells run sub-shells, so calling shell state doesn’t get changed
    • i.e. bash scripts can’t change the calling shells with cd
  • Bash variables:
    • Create them using var_name="value"
    • Reference them with $var_name
    • Variables are empty by default
  • Single quotes in bash are interpreted as literals, double quotes insert variable names
    • Somewhat similar to f-strings
  • Dollar sign number variables (e.g. $1) are reserved and bound to arguments
    • $# refers to the number of arguments (not including program name)
    • $@ refers to all the arguments
  • Command line substitution: var_name=$(expression)
  • Sequence command: $(seq start stop)
    • Note stop is inclusive
  • Loop syntax:
    • Start with for var_name in variable
    • Begin body with do
    • End with done
    • It can iterative over command line arguments
  • Math in bash:
    • Either use let syntax and double quotes
    • Or use $((expression))
  • If statements:
    • if [ $a -ge $b ]; then echo "a is greater than b" fi
    • Square brackets are interpreted as a test alias
    • Add else betwen then and fi for else
    • Use elif for else-if
    • Use || to OR expressions together
    • Use && to AND expressions together
  • Exit codes:
    • We can use the exit code to know how a program terminated
    • The exit code for the previous command is stored in $?
    • Successful exit code is 0, non-zero exit codes are failures
    • exit command sets exit code to zero by default
      • exit num sets exit code to num