CS107 - Looking Back

Unix and command line tools are extremely popular tools outside of CS107 for tasks like running programs (web servers, python programs, remote programs...), accessing remote servers (Amazon Web Services, Microsoft Azure, Heroku...), programming embedded devices (Raspberry Pi, etc.), and more. Our goal for CS107 was to help you become proficient in navigating Unix. It wasn't that long ago that we were introducing the command line and commands like cd for the first time!

Our goal was also to get you up to speed writing programs in C. It wasn't that long ago that we were being introduced to our first C program!

/*
* hello.c
* This program prints a welcome message 
* to the user.
*/
#include  // for printf

int main(int argc, char *argv[]) { 
    printf("Hello, world!\n"); 
    return 0;
}

Coding Style: Writing clean, readable code is crucial for any computer science project. Unfortunately, a fair amount of existing code is poorly-designed/documented. Our goal for CS107 was to help you write with good coding style, and read, understand and comment provided code.

Debugging (GDB): Debugging is a crucial skill for any computer scientist. Our goal for CS107 was to help you become a better debugger, specifically in the steps of narrowing in on bugs, diagnosing issues, and implementing fixes. Practically every project you work on will have debugging facilities, whether it's Python (PDB), IDEs with built-in debuggers (QT Creator, Eclipse) or web development (in-browser debugger).

Testing (Sanity Check): Testing is a crucial skill for any computer scientist. Our goal for CS107 was to help you become a better tester, especially with tasks such as writing targeted tests to validate correctness, using tests to prevent "regressions" (breaking previously-implemented functionality) and using tests to develop incrementally.

Memory Checking and Profiling (Valgrind / Callgrind): Memory checking and profiling are crucial for any computer scientist to analyze program performance and increase efficiency. Many projects you work on will have profiling and memory analysis facilities: for example, mobile development has integrated tools (Xcode Instruments, Android Profiler, etc.), and web development has in-browser tools.

You’ll see manifestations of these tools throughout projects you work on. We hope you can use your CS107 knowledge to take advantage of them!

Key question: How can a computer represent integer numbers?

Why does this matter? Limitations of representation and arithmetic impact programs! We can also efficiently manipulate data using bits.

https://arstechnica.com/information-technology/2014/12/gangnam-style-overflows-int_max-forces-youtube-to-go-64-bit/

Key question: How can a computer represent and manipulate more complex data like text?
Strings in C are arrays of characters ending with a null terminator! We can manipulate them using pointers and C library functions (many of which you could probably implement).

Why does this matter? Understanding this representation is key to efficient string manipulation. This is also how strings are represented in both low- and high-level languages such as C++ and Python.

Key question: How can we effectively manage all types of memory in our programs?
Arrays let us store ordered lists of information. Pointers let us pass addresses of data instead of the data itself. We can use the stack, which cleans up memory for us, or the heap, which we must manually manage.

Why does this matter? The stack and heap allow for two ways to store data in our programs, each with their own tradeoffs, and it’s crucial to understand the nuances of managing memory in any program you write! Pointers also let us pass around references to data efficiently.

Key question: How can we use our knowledge of memory and data representation to write code that works with any data type?
We can use void * to circumvent the type system, memcpy, etc. to copy generic data, and function pointers to pass logic around.

Why does this matter? Working with any data type lets us write more generic, reusable code. Using generics also helps us better understand the type system in C and other languages, and where it can help and hinder our program.

Key question: How does a computer interpret and execute C programs?
GCC compiles our code into machine code instructions executable by our processor. Our processor uses registers and instructions like mov to manipulate data.

Why does this matter? C is higher level and transferrable across machines. But it is not the level of abstraction used to execute our programs. Understanding how programs are compiled and executed, as well as computer architecture, is key to writing performant programs (e.g. fewer lines of code is not necessarily better). We can also reverse engineer and exploit programs at the assembly level!

Key question: How do core memory-allocation operations like malloc and free work?
A heap allocator manages a block of memory for the heap and completes requests to use or give up memory space. We can manage the data in a heap allocator using headers, pointers to free blocks, or other designs

Why does this matter? Designing a heap allocator requires making many design decisions to optimize it as much as possible. There is no perfect design! All languages have a "heap", but manipulate it in different ways.

Key question: How do we act responsibly in maintaining security, protecting privacy, and ensuring warranted trust in the systems we build and maintain?

Takeaways: Responsible programming involves documentation that allows others to evaluate the reliability of your code and makes it more likely that critical vulnerabilities can be detected. Responsible system and program design requires considering data privacy. Deciding how to secure a system might also require creating a trust model and deciding to whom to be partial.

Why does this matter? Programming tools and techniques like those covered in 107 play a role in crucial systems on which people rely. Ethical reflection and considering issues before they arise will help you to make choices you stand behind and are proud of when you write and maintain these programs in the future.