reveal.js

# Using the Command Line

---

CS 130 // 2021-09-01

## Administrivia
- Your assignment 1 questionnaire should have been turned in before class
- 
 The CS Desktop is still having troubles...
    + I recommend that all of you [install GCC and VSCode natively](/teaching/2021f/cs130/resources/installing-visual-studio-code)
- 
 If you're still having trouble compiling and running C code after today, please [schedule an appointment](https://calendly.com/titus-klinge) with me in my office hours

# Questions
## ...about anything?

## Overarching Theme
- Learning how a high-level program is actually executed on your computer's processor

![Compiler-Assembler Diagram](/teaching/2021f/cs130/assets/images/COD/processor-components.png)

![Compiler-Assembler Diagram](/teaching/2021f/cs130/assets/images/COD/compiler-assembler.png)

# Command Line Interfaces

## Command Line Interfaces
- A **command line** is a *textual* interface to your computer
    + 
 Also called a **Terminal**
    + 
 Also called a **Shell**
- 
 A terminal is similar to a file browser such as Windows Explorer or MacOS Finder

## Command Line Interfaces
- Each OS has their own version of a terminal
    + 
 **PowerShell** is primarily used on Windows 10
    + 
 **Command Prompt** another Windows terminal primarily used on older versions of Windows
    + 
 **Terminal** is the app on MacOS

## Basics of a CLI
- `pwd`
    + Prints the **working directory**
- 
 `cd new_directory`
    + Changes the working directory to `new_directory`
- 
 `ls`:
    + Lists the files and folders in the working directory

## Basics of a CLU
- Notice that a pattern has emerged...
- 
 All commands are of the form:
    + `command arg1 arg2 ...`
- 
 Here `command` is a program
- 
 `arg1`, `arg2`, etc. are the **command line arguments** to the program

## Example: Using Python
- Consider the Python program `hello.py`:
    ```py
    def main():
        print("Hello, world!")

if __name__ == "__main__":
        main()
    ```
- 
 We can run this program on the CLI by executing
    ```shell
    $ python3 hello.py
    ```
- 
 `$` is the **prompt** and is not meant to be typed in
    + 
 On Windows, the prompt is a `>` character

## Example: Using Args
- Consider the Python program `greet.py`:
    ```py
    import sys

def main():
        if len(sys.argv) == 2:
            name = sys.argv[1]
            print(f"Hello, {name}!")
        elif len(sys.argv) == 1:
            print("No name was provided!")
        else:
            print("Too many args!")

if __name__ == "__main__":
        main()
    ```

## Example: Java Args
- Consider the equivalent program `Greet.java`:
    ```java
    public class Greet {
        public static void main(String[] args) {
            String message;
            if (args.length == 1) {
                message = "Hello, " + args[0] + "!";
            } else if (args.length == 0) {
                message = "No name was provided!";
            } else {
                message = "Too many args!";
            }
            System.out.println(message);
        }
    }
    ```

## Why Learn to Use a CLI?
- As programmers, it is sometimes very convenient to write programs that interact with the user via CLI
    + 
 Logging state of the program for debugging
    + 
 Get textual input for later use
- 
 Once you build up familiarity using a CLI, you will find that certain tasks are **much easier** on the command line

# Demo

## More Basic Commands
```bash
cd directory_name       # change directory
ls                      # list files/folders
pwd                     # print working directory
mkdir directory_name    # make directory
mv dir1 dir2            # move/rename directory
mv file1 file2          # move/rename file
rm file                 # remove file
rm -r directory         # remove directory (recursively)
```

## Other Useful Facts
- `.` is an alias for **current directory**
    + `./program` means: "execute the `program` file that is in this directory"
- 
 `..` is an alias for **parent directory**
    + e.g., `cd ..` means: "go up one directory"
- 
 Most CLI programs have an optional argument named `--help`
    ```shell
    gcc --help
    ```

## PowerShell VS Bash
- Linux and MacOS both use **bash** terminals, which have standardized commands
- However, Windows PowerShell is **entirely different** but is gracious enough to support the basic CLI commands we've covered today
    + 
 The easiest way to get a bash terminal on Windows 10 is to install the [Windows Subsystem for Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10) (WSL)
    + 
 This is **not** required for this course, but WSL is becoming widely used in industry

## Using GCC and VSCode
- I **highly recommend** creating a folder on your computer and opening it inside VSCode
    + 
 File -> Open Folder
- 
 When you have a folder opened in VSCode, the terminal's working directory is automatically initialized to the open folder

# Overview of C

## Why learn C?
- C is the most commonly used programming language in the world

## Why learn C?
- C is the most commonly used programming language in the world
- Applications are still written in C
    + Linux kernel, Windows, drivers, video games, ...

## C Design Background
- C was originally designed in the 1970s
    + At the time, computers were not very powerful and had limited memory
- 
 C was designed to be **efficient**
    + But still ridiculously convenient in comparison to programming in assembly
- 
 "The programmer is always right"
    + There is very little error checking
    + 
 Error messages are usually no help at all

## Interpreted VS Compiled
- Python is an **interpreted** language
    + A `program.py` is fed into an **interpreter** which executes it directly
- 
 C is a **compiled** language
    + `program.c` is fed into a **compiler** which produces an executable file
    + 
 This executable is custom to your OS and CPU
- 
 For Java, `program.java` is compiled into "Java bytecode" which is then interpreted by the Java Virtual Machine (JVM)

## Random Trivia
- What language is the Python interpeter written in?
    + 
 C
- 
 What language is the JVM written in?
    + 
 C
- 
 What language is the C compiler written in?
    + 
 C

## Compiler Diagram

- **Compiler**: Converts C into assembly language
- **Assembler**: Converts assembly into machine code
- **Linker**: Combines machine code files into an executable
- **Loader**: Loads an executable into memory and executes it

</div>

<div>

![C Program Compiler Process](/teaching/2021f/cs130/assets/images/COD/compiler-diagram.png)

</div>
</div>

# C Progams

## An Example

```c
#include  "stdio.h"
int main()
{
    char name[20];
    int age;
    printf("Hi! What is your name?\n");
    scanf("%s", name);
    printf("Hello, %s, it is nice to meet you!\n", name);
    printf("What is your age?\n");
    scanf("%d", &age);
    printf("Wow, %d is pretty old!\n", age);
    return 0;
}
```

```py
# Python equivalent
name = input("Hi! What is your name?\n")
print("Hello,", name, "it is nice to meet you!")
age = int(input("What is your age?\n"))
print("Wow,", age, "is pretty old!")
```

## Variables and Types
- In C, the **type** of a variable must be declared before it is first used
    ```c
    int x = 3 + 4;   // Must give a type the first time
    ...
    x = x + 1;
    ```

## Variables and Types
- Integers

```c
int x = 5;            // usually 32-bits
long y = -13;         // usually 64-bits
short z = 7;          // usually 16-bits
unsigned int u = 7;   // makes number interpreted as positive
```

- 
 Floating point

```c
float f = 3.14;       // usually 32-bits
double d = -7.123;    // usually 64-bits
```

## Variables and Types
- Character
    ```c
    char c = 'a';       // usually 8-bits
    ```
- 
 No Boolean type---uses `int` instead
    + `0` means false
    + Any other `int` is true

## Comments
- Uses `/* ... */` for multi-line comments
- Uses `// ...` for single-line comments

```c
/* This is a comment that spans
   multiple lines. Everything
   in-between is ignored */

int x = 10;  // This is a single line comment.
x = x + 5;   // Everything after it is ignored.
```

## Operators
- C uses symbols `||`, `&&`, and `!` for Boolean expressions instead of `and`, `or`, and `not`

```py
# Python code
result = ((a > 0 or b > 0) and (c > 0)) == False
```

```c
int result = ((a > 0 || b > 0) && c > 0) == 0;
```

## Operators
- `a / b` behaves differently in C
    + Does **integer division** if both are integral
    + Does **floating point division** if one or both are floating point

## For Loops
- In C, the `for` loop means something else entirely
- The following two code blocks are equivalent

```c
for (init; test; update) {
    body
}
```

```c
init
while (test) {
    body
    update
}
```

## For Loops
- A common use is to iterate through an array

```c
int arr[5] = {7, 3, 1, 2, 10};
for (int i = 0; i < 5; i++) {
    printf("The next value is: %d\n", arr[i]);
}
```

```py
arr = [7, 3, 1, 2, 10]
for i in range(10):
    print("The next value is:", arr[i])
```

## Arrays
- Fixed size---they cannot be made smaller or larger
- 
 No way to check its size after creation
- 
 No index out of bounds checks

```c
int arr[50];           // creates an array with 50 spots
int val = arr[60];     // will happily try to do this
printf("%d", val);
```

## Functions
```c
void swap(int v[], int k)
{
    int temp = v[k];
    v[k] = v[k+1];
    v[k+1] = temp;
}

void sort (int v[], int n)
{
    for (int i = 0; i < n; i++) {
        for (int j = i - 1; j >= 0 && v[j] > v[j + 1]; j--) {
            swap(v, j); 
        }
    } 
}
```

## Exercises
- Start by setting up **Visual Studio Code** on your computer
- You will need the [C/C++ extension](https://marketplace.visualstudio.com/items?itemName=ms-vscode.cpptools)
- If you are running Windows, you will also to follow the [Using GCC with MinGW](https://code.visualstudio.com/docs/cpp/config-mingw) tutorial to install the C compiler

## Exercise 1
- Write a program that asks the users to type in four numbers and prints the average of those four numbers

## Exercise 2
- Create a function `void reverse(int arr[], int n)` that takes an array with `n` elements and reverses the order of the elements
- Test it out in a `main` function such as:

```c
int main()
{
    int arr[5] = {1, 2, 3, 4, 5};
    reverse(arr, 5);
    for (int i = 0; i < 5; i++) {
        printf("The next value is: %d\n", arr[i]);
    }
    return 0;
}
```