diff --git a/ex1/ex1.c b/ex1/ex1.c
index c4b111641..dc03781c0 100644
--- a/ex1/ex1.c
+++ b/ex1/ex1.c
@@ -8,7 +8,25 @@
 
 int main(void)
 {
-    // Your code here
+    int x = 100;
+
+    printf("pre-fork: parent pid %d, x = %d \n", (int)getpid(), x);
+
+    int rc = fork();
+
+    if (rc < 0)
+    {
+        fprintf(stderr, "fork failed\n");
+        exit(1);
+    }
+    else if (rc == 0)
+    {
+        printf("post-fork: child pid %d, x = %d \n", (int)getpid(), x);
+    }
+    else
+    {
+        printf("post-fork: parent pid %d of child %d, x = %d\n", (int)getpid(), rc, x);
+    }
 
     return 0;
 }
diff --git a/ex2/ex2.c b/ex2/ex2.c
index 4245375b9..b183be4ba 100644
--- a/ex2/ex2.c
+++ b/ex2/ex2.c
@@ -1,5 +1,5 @@
-// Write a program that opens the text.txt file (with the `fopen()` library call) located in this directory 
-// and then calls `fork()` to create a new process. Can both the child and parent access the file descriptor 
+// Write a program that opens the text.txt file (with the `fopen()` library call) located in this directory
+// and then calls `fork()` to create a new process. Can both the child and parent access the file descriptor
 // returned by `fopen()`? What happens when they are written to the file concurrently?
 
 #include <stdio.h>
@@ -8,7 +8,27 @@
 
 int main(void)
 {
-    // Your code here 
-    
+    FILE *file = fopen("text.txt", "r+");
+
+    fprintf(file, "pre-fork text\n");
+
+    int rc = fork();
+
+    if (rc < 0)
+    {
+        fprintf(stderr, "fork failed\n");
+        exit(1);
+    }
+    else if (rc == 0)
+    {
+        printf("post-fork: child pid %d\n", (int)getpid());
+        fprintf(file, "child text\n");
+    }
+    else
+    {
+        printf("post-fork: parent pid %d of child %d\n", (int)getpid(), rc);
+        fprintf(file, "parent text\n");
+    }
+
     return 0;
 }
diff --git a/ex3/ex3.c b/ex3/ex3.c
index 3a3698c1f..b5ad768d2 100644
--- a/ex3/ex3.c
+++ b/ex3/ex3.c
@@ -9,7 +9,26 @@
 
 int main(void)
 {
-    // Your code here
+    printf("pre-fork: pid %d\n", (int)getpid());
+
+    int rc = fork();
+
+    if (rc < 0)
+    {
+        fprintf(stderr, "fork failed\n");
+        exit(1);
+    }
+    else if (rc == 0)
+    {
+        printf("post-fork: child pid %d\n", (int)getpid());
+        printf("hello\n");
+    }
+    else
+    {
+        int wc = waitpid(rc, NULL, 0);
+        printf("post-fork: parent pid %d of child %d\n", (int)getpid(), rc);
+        printf("goodbye\n");
+    }
 
     return 0;
 }
diff --git a/ex4/ex4.c b/ex4/ex4.c
index 0221ca96e..76f5e332e 100644
--- a/ex4/ex4.c
+++ b/ex4/ex4.c
@@ -1,6 +1,6 @@
 // Write a program that calls `fork()` and then calls some form of `exec()`
-// to run the program `/bin/ls`. Try a few variants of `exec()`, such as 
-// `execl()`, `execle()`, `execv()`, and others. Why do you think there 
+// to run the program `/bin/ls`. Try a few variants of `exec()`, such as
+// `execl()`, `execle()`, `execv()`, and others. Why do you think there
 // are so many variants of the same basic call?
 
 #include <stdio.h>
@@ -10,7 +10,26 @@
 
 int main(void)
 {
-    // Your code here    
+    printf("pre-fork: pid %d\n", (int)getpid());
+
+    int rc = fork();
+
+    if (rc < 0)
+    {
+        fprintf(stderr, "fork failed\n");
+        exit(1);
+    }
+    else if (rc == 0)
+    {
+        printf("post-fork: child pid %d\n", (int)getpid());
+
+        execl("/bin/ls", "ls", NULL);
+    }
+    else
+    {
+        int wc = waitpid(rc, NULL, 0);
+        printf("post-fork: parent pid %d of child %d\n", (int)getpid(), rc);
+    }
 
     return 0;
-}
+}
\ No newline at end of file
diff --git a/ex5/ex5.c b/ex5/ex5.c
index cbf3b8e61..fa828bc91 100644
--- a/ex5/ex5.c
+++ b/ex5/ex5.c
@@ -1,7 +1,7 @@
 // Write a program that forks a child and creates a shared pipe
-// between the parent and child processes. Have the child write 
-// the three messages to the parent and have the parent print out 
-// the messages. 
+// between the parent and child processes. Have the child write
+// the three messages to the parent and have the parent print out
+// the messages.
 
 #include <stdio.h>
 #include <unistd.h>
@@ -10,13 +10,50 @@
 
 #define MSGSIZE 16
 
-char* msg1 = "hello world #1";
-char* msg2 = "hello world #2";
-char* msg3 = "hello world #3";
+char *msg1 = "hello world #1";
+char *msg2 = "hello world #2";
+char *msg3 = "hello world #3";
 
 int main(void)
 {
-    // Your code here
-    
+    char inbuff[MSGSIZE];
+    int p[2];
+
+    if (pipe(p) < 0)
+    {
+        printf("Pipe failed\n");
+        exit(1);
+    }
+
+    printf("pre-fork: pid %d\n", (int)getpid());
+
+    int rc = fork();
+
+    if (rc < 0)
+    {
+        fprintf(stderr, "fork failed\n");
+        exit(1);
+    }
+    else if (rc == 0)
+    {
+        printf("post-fork: child pid %d\n", (int)getpid());
+
+        write(p[1], msg1, MSGSIZE);
+        write(p[1], msg2, MSGSIZE);
+        write(p[1], msg3, MSGSIZE);
+    }
+    else
+    {
+        int wc = waitpid(rc, NULL, 0);
+        printf("post-fork: parent pid %d of child %d\n", (int)getpid(), rc);
+
+        for (int i = 0; i < 3; i++)
+        {
+            read(p[0], inbuff, MSGSIZE);
+
+            printf("% s\n", inbuff);
+        }
+    }
+
     return 0;
 }