Homework 0
----------

### Watch the videos and write up your answers to the following questions

**Important!**

The virtual machine-in-your-browser and the videos you need for HW0 are here:

<http://cs-education.github.io/sys/>

Questions? Comments? Use Piazza: <https://piazza.com/illinois/spring2019/cs241>

The in-browser virtual machine runs entirely in Javascript and is fastest in Chrome. Note the VM and any code you write is reset when you reload the page, **so copy your code to a separate document.** The post-video challenges are not part of homework 0 but you learn the most by doing rather than just passively watching - so we suggest you have some fun with each end-of-video challenge.

HW0 questions are below. Please use this document to write the answers. This will be hand graded.

### Chapter 1

In which our intrepid hero battles standard out, standard error, file descriptors and writing to files

1.  **Hello, World! (system call style)** Write a program that uses `write()` to print out “Hi! My name is &lt;Your Name&gt;”.

```c
#include <unistd.h>
int main() {
	write(1,"Hello, my name is Reetahan Mukhopadhyay", 39);
	return 0;
}
```

2.  **Hello, Standard Error Stream!** Write a function to print out a triangle of height `n` to standard error. Your function should have the signature `void write_triangle(int n)` and should use `write()`. The triangle should look like this, for n = 3:

```
*
**
***
```

```c
void write_triangle(int n) {
	int i;
	int j;
	for(i = 1; i <= n; i++){
		for(j = 0; j < i; j++){
			write(STDERR_FILENO,"*", 1);
		}
		write(STDERR_FILENO,"\n", 1);
	}
}
```

3.  **Writing to files** Take your program from “Hello, World!” modify it write to a file called `hello_world.txt`. Make sure to to use correct flags and a correct mode for `open()` (`man 2 open` is your friend).

```c
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>

int main() {
    mode_t mode = S_IRUSR | S_IWUSR;
    int fileDescrip = open("hello_world.txt",O_CREAT | O_TRUNC | O_RDWR, mode);
    write(fileDescrip,"Hello, my name is Reetahan Mukhopadhyay", 39);
    close(fileDescrip);
    return 0;
}
```

5. **Not everything is a system call** Take your program from “Writing to files” and replace `write()` with `printf()`. *Make sure to print to the file instead of standard out!*

```c
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>

int main() {
    mode_t mode = S_IRUSR | S_IWUSR;
    close(1);
    int fileDescrip = open("hello_world.txt",O_CREAT | O_TRUNC | O_RDWR, mode);
    printf("Hello, my name is Reetahan Mukhopadhyay \n %d", fileDescrip);
    close(fileDescrip);
    return 0;
}
```

6.  What are some differences between `write()` and `printf()`?

Some of the differences include the fact that write() is a system call - so it is not a part of an application,
but interacts with the kernel - that is designed to send bytes to a given output location. printf() is a wrapper around write()
that exists in a C standard library of functions. It is more useful for formatting and more complex text to output. Since systems calls may be costly, printf() uses a buffer, so it holds the characters before making a call to write until it can hold no more or is flushed by other means,
such as a new line.

### Chapter 2

Sizing up C types and their limits, `int` and `char` arrays, and incrementing pointers

1.  How many bits are there in a byte?

  At least 8 bits.

2.  How many bytes are there in a `char`?

```c
  1
```

3.  How many bytes the following are on your machine?

* `int`: 4
* `double`: 8
* `float`: 4
* `long`: 8
* `long long`: 8

4.  On a machine with 8 byte integers, the declaration for the variable `data` is `int data[8]`. If the address of data is `0x7fbd9d40`, then what is the address of `data+2`?

```c
  0x7fbd9d50
```

5.  What is `data[3]` equivalent to in C? Hint: what does C convert `data[3]` to before dereferencing the address? Remember, the type of a string constant `abc` is an array.

```c
data[3] is equivalent to 3[data] and *(data+3).
```

6.  Why does this segfault?

```c
char *ptr = "hello";
*ptr = 'J';
```
It segfaults because "hello" is a constant - in the text segment, thus is read-only memory, thus when it attempts to edited, we have a segfault.

7.  What does `sizeof("Hello\0World")` return?

```c
12
```

8.  What does `strlen("Hello\0World")` return?

```c
5
```

9.  Give an example of X such that `sizeof(X)` is 3.

```c
X = "ab"
```

10. Give an example of Y such that `sizeof(Y)` might be 4 or 8 depending on the machine.

```c
  Y = int *
```

### Chapter 3

Program arguments, environment variables, and working with character arrays (strings)

1.  What are two ways to find the length of `argv`?

  You can either simply state the value of argc, or loop through argv, keeping a counter for each value, until you reach a null.

2.  What does `argv[0]` represent?

  The execution name of the program.

3.  Where are the pointers to environment variables stored (on the stack, the heap, somewhere else)?

   The pointers to environmental variables are on the stack (although these variables themselves exist in a region above
     the stack.)

4.  On a machine where pointers are 8 bytes, and with the following code:

    ``` c
    char *ptr = "Hello";
    char array[] = "Hello";
    ```

    What are the values of `sizeof(ptr)` and `sizeof(array)`? Why?

```c
The value of `sizeof(ptr)` will be a varying value by machine but typically 8 bytes, while `sizeof(array)` will be 6 bytes.
This is because `sizeof(ptr)` will tell you the size of a pointer on the machine, while `sizeof(array)` will tell you the size of needed to hold the array - the sum of each of the 5 characters, which are 1 byte each, plus 1 byte for the null character to make 6.
```

5.  What data structure manages the lifetime of automatic variables?

    A stack.

### Chapter 4

Heap and stack memory, and working with structs

1.  If I want to use data after the lifetime of the function it was created in ends, where should I put it? How do I put it there?

    You should put it in the heap. You can do these by calling the malloc() function.

2.  What are the differences between heap and stack memory?

    Heap memory starts at low address values and grows up, while stack memory starts at high addresses and grows down.
    The stack is where automatic variables are placed, and when a function exits, the values of those variables may no longer
    exist as the frame is taken down. However, when memory is allocated on the heap, it will exist until it is freed manually or at program exit.

3.  Are there other kinds of memory in a process?

  A process contains stack memory, heap memory, and the data segment - which contains things like global variables and static local variables.

4.  Fill in the blank: “In a good C program, for every malloc, there is a \_\_\_”.

    free

5.  What is one reason `malloc` can fail?

    If it is incapable of allocating the amount of bytes requested, like when the process would be running out of (virtual) memory.

6.  What are some differences between `time()` and `ctime()`?

    time() returns the number of seconds since 1970. ctime() returns a formatted string - a pointer to an (ASCII) character - of the current
    date and time.

7.  What is wrong with this code snippet?

``` c
free(ptr);
free(ptr);
```

This is a double free. When the first free is called, the heap may use that memory for other purposes - thus, we will have undefined behavior.

8.  What is wrong with this code snippet?

``` c
free(ptr);
printf("%s\n", ptr);
```
We have a freed pointer that is being called to again. As said, once the memory is freed, we shouldn't considered the memory valid as it may be being used elsewhere
now in the program. Thus, we have some undefined behavior.

9.  How can one avoid the previous two mistakes?

  Once we freed a pointer, set the pointer to be NULL.

10. Use the following space for the next four questions

```c
#include <stdlib.h>

struct Person {
	char* name;
	int age;
	struct Person* friends [];
};

typedef struct Person person_t;

person_t* create(char* name, int age);
void destroy(person_t* toDelete);


int main() {

	person_t* agentSmith = create("Agent Smith", 128);
	person_t* sonnyMoore = create("Sonny Moore", 256);

	(agentSmith->friends)[0] = sonnyMoore;
	(sonnyMoore->friends)[0] = agentSmith;

	printf("Name: %s  Age: %d  Friends: %s \n", agentSmith->name, agentSmith->age, agentSmith->friends[0]->name);
	printf("Name: %s  Age: %d  Friends: %s \n", sonnyMoore->name, sonnyMoore->age, sonnyMoore->friends[0]->name);
	return 0;
}


person_t* create(char* name, int age){
	person_t* toReturn = (person_t*) malloc(sizeof(person_t));
	toReturn->name = name;
	toReturn->age = age;
	toReturn->friends[10];
	return toReturn;
}

void destroy(person_t* toDelete){
	free(toDelete->name);
	toDelete->name = NULL;
	free(toDelete->friends);
	memset(toDelete,0,sizeof(person_t));
	free(toDelete);

}
```

* Create a `struct` that represents a `Person`. Then make a `typedef`, so that `struct Person` can be replaced with a single word. A person should contain the following information: their name (a string), their age (an integer), and a list of their friends (stored as a pointer to an array of pointers to `Person`s).

*  Now, make two persons on the heap, “Agent Smith” and “Sonny Moore”, who are 128 and 256 years old respectively and are friends with each other. Create functions to create and destroy a Person (Person’s and their names should live on the heap).

* `create()` should take a name and age. The name should be copied onto the heap. Use malloc to reserve sufficient memory for everyone having up to ten friends. Be sure initialize all fields (why?).

* `destroy()` should free up not only the memory of the person struct, but also free all of its attributes that are stored on the heap. Destroying one person should not destroy any others.


### Chapter 5

Text input and output and parsing using `getchar`, `gets`, and `getline`.

1.  What functions can be used for getting characters from `stdin` and writing them to `stdout`?

      You can use getchar() to get characters from the stdin and putchar() to write them out to stdout.

2.  Name one issue with `gets()`.

  If our input is larger than the size of the characters we set to read from the input (the buffer), then
  we may overwrite memory being used for other things.

3.  Write code that parses the string “Hello 5 World” and initializes 3 variables to “Hello”, 5, and “World”.

```c
#include <stdarg.h>

#include <stdio.h>

int main() {
	char* data = "Hello 5 World";

	char buffer1[7];
	int num = 0;
	char buffer2[7];

	int result = sscanf(data, "%7s %d %7s",buffer1,&num,buffer2);
	printf("Result: %d First word: %s Number: %d Second word: %s",result,buffer1,num,buffer2);
	return 0;
}

```

4.  What does one need to define before including `getline()`?

  ```C
  #define _GNU_SOURCE
  ```
5.  Write a C program to print out the content of a file line-by-line using `getline()`.

```c
#include <stdio.h>
#define _GNU_SOURCE
#include <stdlib.h>

int main() {

	FILE* tempFile = fopen("example.txt","r");
	char* buffer = NULL;
	size_t capacity = -42;

	while(getline(&buffer,&capacity,tempFile) != -1){
		printf("%s",buffer);
	}

	fclose(tempFile);
	free(buffer);
	return 0;
}

```

### C Development

These are general tips for compiling and developing using a compiler and git. Some web searches will be useful here


1.  What compiler flag is used to generate a debug build?

  The "-g" flag.

2.  You fix a problem in the Makefile and type `make` again. Explain why this may be insufficient to generate a new build.

  If you just type 'make' it may only rebuild the updated files and not rebuild any files that were already built.

3.  Are tabs or spaces used to indent the commands after the rule in a Makefile?

  Tabs.

4.  What does `git commit` do? What’s a `sha` in the context of git?

    "git commit" will save the current directory's state (changes) to its git repository, with a message. A 'sha', known as
    a 'SHA-1' is a checksum hash that tags every commit (it's a hash of some metadata with the commit), that should act as an
    identifier.

5.  What does `git log` show you?

  It shows the history of commits.

6.  What does `git status` tell you and how would the contents of `.gitignore` change its output?

 "git status" tells you the state of the current repository - like what files/folders are/aren't being tracked by Git,
 and what files/folders are/aren't staged for a commit. A ".gitignore" file would give the types of untracked files that
  "git status" would not list as untracked, as the user intentionally wants them to be ignored.

7.  What does `git push` do? Why is it not just sufficient to commit with `git commit -m ’fixed all bugs’ `?

  "git push" will push all the changes committed in the local repository to the remote repository. Just committing changes
  will not make a change on the remote repository.

8.  What does a non-fast-forward error `git push` reject mean? What is the most common way of dealing with this?

  It means Git cannot push the changes to the remote repository without losing other commits. The remedy is to pull
  the current state of the branch and to repair any conflicts before pushing again.

### Optional: Just for fun

-   Convert your a song lyrics into System Programming and C code covered in this wiki book and share on Piazza.

-   Find, in your opinion, the best and worst C code on the web and post the link to Piazza.

-   Write a short C program with a deliberate subtle C bug and post it on Piazza to see if others can spot your bug.

-   Do you have any cool/disastrous system programming bugs you’ve heard about? Feel free to share with your peers and the course staff on piazza.