Lecture 10: Potpourri (2020)

Lecture 10: Potpourri (2020) - Missing Semester

Summary

This lecture, "Potpourri," acts as a catch-all for various useful, yet sometimes overlooked, tools and concepts that enhance a programmer's workflow and understanding. It covers a range of topics including shell scripting for automation, basic system administration concepts like file permissions and process management, debugging techniques, and an introduction to performance profiling. The overarching theme is to equip students with practical skills that go beyond core programming languages to become more effective and efficient developers.

Key Takeaways

* **Shell Scripting is Powerful:** Automate repetitive tasks, combine command-line tools, and create custom workflows.

* **Understanding File Permissions:** Crucial for security and proper system operation (read, write, execute for owner, group, others).

* **Process Management is Essential:** Monitor, control, and understand the processes running on your system (`ps`, `top`, `kill`).

* **Debugging is a Skill:** Learn to systematically identify and fix errors using tools like `gdb` and by understanding program flow.

* **Performance Matters:** Identify performance bottlenecks and use profiling tools to optimize code.

* **Version Control (Git) is Non-Negotiable:** Essential for collaboration, tracking changes, and managing code history.

* **Command-Line Power:** Leverage the command line for efficiency and access to a vast array of tools.

Detailed Notes

---

I. Shell Scripting

* **Purpose:** Automate repetitive tasks, combine command-line utilities, create workflows.

* **Basic Structure:**

* Shebang line (`#!/bin/bash` or `#!/bin/sh`) indicates the interpreter.

* Commands executed sequentially.

* **Variables:**

* Assignment: `my_var="some_value"`

* Usage: `$my_var` or `${my_var}` (curly braces are good for disambiguation).

* **Control Flow:**

* `if/then/else`: Conditional execution.

* `for` loops: Iterating over lists or ranges.

* `while` loops: Executing until a condition is false.

* **Functions:** Reusable blocks of code.

```bash

my_function() {

echo "This is a function."

}

my_function

```

* **Arguments:** Accessing script arguments: `$1`, `$2`, `$@` (all arguments).

* **Exit Status:**

* `0`: Success

* Non-zero: Failure

* Check with `$?`.

* **Example Use Cases:**

* Automated backups.

* Compiling and deploying code.

* Processing log files.

---

II. System Administration Fundamentals

#### A. File Permissions

* **Concept:** Control who can access and modify files and directories.

* **Three Categories:**

* **Owner:** The user who owns the file.

* **Group:** Users in a specific group.

* **Others:** Everyone else.

* **Three Permissions:**

* **Read (r):** View file contents or list directory contents.

* **Write (w):** Modify file contents or create/delete files in a directory.

* **Execute (x):** Run a file (if it's a program) or enter a directory.

* **Representation:**

* **Symbolic:** `rwx`, `rw-`, `r--`, etc.

* **Octal:**

* `r = 4`

* `w = 2`

* `x = 1`

* Sum for each category (e.g., `rwx` = 4+2+1 = 7, `rw-` = 4+2 = 6, `r--` = 4).

* Example: `rwxr-xr--` is `754`.

* **Commands:**

* `ls -l`: Display file permissions.

* `chmod`: Change permissions (e.g., `chmod 755 my_script.sh`).

* `chown`: Change owner.

* `chgrp`: Change group.

#### B. Process Management

* **Concept:** Managing the programs and tasks running on your system.

* **Key Commands:**

* `ps`: List running processes.

* `ps aux`: Show all processes for all users, including those without a terminal.

* `top`: Real-time process monitoring (CPU usage, memory, etc.).

* `kill`: Send signals to processes.

* `kill PID`: Terminate a process (default signal is SIGTERM, graceful shutdown).

* `kill -9 PID`: Forcefully kill a process (SIGKILL, immediate termination).

* **Process ID (PID):** A unique identifier for each running process.

---

III. Debugging

* **Concept:** The process of finding and fixing errors (bugs) in software.

* **General Strategies:**

* **Understand the Error Message:** Read and interpret stack traces and error output carefully.

* **Reproduce the Bug:** Find a consistent way to trigger the error.

* **Isolate the Problem:** Narrow down the code section where the bug might be occurring.

* **Print Statements (Poor Man's Debugging):** Add `print` or `echo` statements to track variable values and program flow.

* **Debuggers (e.g., `gdb` for C/C++):**

* **Breakpoints:** Pause execution at specific lines of code.

* **Stepping:** Execute code line by line (`next`, `step`).

* **Inspecting Variables:** View the values of variables at any point.

* **Backtrace:** See the call stack to understand how the program reached the current state.

---

IV. Performance Profiling

* **Concept:** Analyzing the runtime performance of a program to identify bottlenecks.

* **Why Profile?** To understand where a program spends its time and optimize the slowest parts.

* **Tools:**

* **`time` command:** Measure the execution time of a command.

* `real`: Wall-clock time.

* `user`: CPU time spent in user mode.

* `sys`: CPU time spent in kernel mode.

* **Language-Specific Profilers:** (e.g., `cProfile` for Python, `gprof` for C/C++). These tools can provide detailed breakdowns of function call times.

* **Focus:** Optimize the "hot spots" – the sections of code that consume the most resources.

---

V. Version Control (Git)

* **Importance:** Essential for managing code changes, collaboration, and historical tracking.

* **Key Concepts:**

* **Repository:** The collection of files and their history.

* **Commit:** A snapshot of your project at a specific point in time.

* **Branch:** An independent line of development.

* **Merge:** Combining changes from one branch into another.

* **Remote Repository:** A copy of your repository hosted elsewhere (e.g., GitHub, GitLab).

* **Basic Workflow:**

1. `git init`: Initialize a new repository.

2. `git add <file>`: Stage changes for commit.

3. `git commit -m "Commit message"`: Save staged changes.

4. `git status`: Check the status of your working directory.

5. `git log`: View commit history.

6. `git clone <url>`: Copy a remote repository.

7. `git push`: Upload local commits to a remote.

8. `git pull`: Download changes from a remote.

---

VI. Command-Line Utilities & Tools

* **`grep`:** Search for patterns in text.

* `grep "pattern" file.txt`

* `grep -r "pattern" directory/` (recursive search)

* **`sed`:** Stream editor for text transformation.

* **`awk`:** Pattern scanning and processing language (powerful for structured text).

* **Piping (`|`):** Chain commands together, sending the output of one command as input to another.

* `ls -l | grep ".txt"`

* **Redirection (`>`, `>>`, `<`):**

* `>`: Redirect output to a file (overwrite).

* `>>`: Redirect output to a file (append).

* `<`: Redirect input from a file.

---