CS107 - Looking Ahead

CS107 is an introduction to systems - how computer systems work under the hood, how programs are compiled and run, and more. CS111 is the natural followup to CS107 if you're interested in learning more - it goes deeper into systems, covering topics such as concurrency (executing multiple tasks simultaneously), filesystems (how files are stored on disk) and more cool topics!

Some questions you might be interested in learning more about:

How is an operating system implemented? (threads, user programs, virtual memory and the filesystem) - take CS111 and CS140/CS112/CS212!
How can all programs assume that they can use the same address space (e.g. NULL to 0xffff....) even when running simultaneously? - take CS111 and CS140/CS112/CS212!
How is a compiler implemented? (lexical analysis, parsing, semantic analysis, code generation) - take CS143!
How can applications communicate over a network? How can we weigh different tradeoffs of network architecture design and efficiently transmit bits across a network? - take CS144!
How can we write programs that execute multiple tasks simultaneously? - take CS111!

Interested in seeing more about how you might design and compile your own programming language? If you want to play around yourself, try making your own copy of the lecture code for the last lecture. The cool subfolder has a demo (read the README file for more info) of the Cool programming language that is used in CS143.

CS107 material connects with different areas of machine learning. Here are a few:

How can we speed up machine learning training with reduced precision computation? Numeric representations, like what we talked about with integer representations, are an interesting area of ML research. The goal is to sacrifice precision by designing smaller numeric representations in order to train machine learning models more quickly. Check out these two articles for some more on this area: IBM and NVIDIA
How can we implement performant machine learning libraries? It turns out that popular Machine Learning tools such as PyTorch and TensorFlow (TF1 internals, TF2 profiler) are implemented using C!

CS107 material connects with different areas of web development - particularly the areas that focus on compiling code to efficiently run in the browser. Here are a few:

The Chrome V8 JavaScript engine converts Javascript into machine code for computers to execute. Check out this article for more info on how it works.
How can we compile programs into an efficient binary instruction format that runs in a web browser? Wouldn't it be cool if we could take one of our C programs and compile it to run in a browser instead of directly on a machine? It turns out that there is an emerging standard instruction format called WebAssembly that runs in browsers. One example of this - running Google Earth (a native program) directly in a web browser. Try it out!

CS107 material touches on different areas of programming languages and runtimes. Here are a few:

How can programming languages and runtimes efficiently manage memory? Manual heap memory management with allocating and freeing (like in C and C++) isn't the only way we can manage heap memory. Other languages implement different systems, with different tradeoffs both in efficiency and programmer work. For example, Swift uses something called "automatic reference counting" and Java uses something called "garbage collection".
How can we design programming languages to reduce the potential for programmer error? - take CS242! Programming languages each have different tradeoffs, and it's interesting to think about how we could design programming languages to reduce or eliminate common sources of difficulty, like segfaults. For instance, Swift has data types called "optionals" - if a variable can be NULL, it must be explicitly declared as such, and otherwise cannot be NULL.
How can we design portable programming languages? We learned about how compiled executables for our C programs are not portable - they may not run on all other machines, since the machine code is processor-specific. How can we get around this limitation. Java uses something called "Java bytecode" and the "Java Virtual Machine" that lets you compile a Java program and send that executable directly to anyone else to run! Check out more info here.

Interested in seeing more about how you might design and compile your own programming language? Check out CS143, a class all about compilers. If you want to play around yourself, try making your own copy of the lecture code for the last lecture - the cool subfolder has a demo (read the README file for more info) of the Cool programming language that is used in CS143!

CS107 material touches on different areas of theory. Here's one example:

How can compilers output efficient machine code instructions for programs? - take CS143! It turns out that languages can be represented as regular expressions and context-free grammars. We can also model programs as control-flow graphs for additional optimization!

We touched on security in the context of assign5, where we learned about assembly, finding exploits, and understanding why these bugs might occur. If you liked the ATM portion of the assignment in particular, you'll love CS155, a class all about security. Here are some more notes on security related to what we've discussed:

How can we find / fix vulnerabilities at various levels in our programs? We can work to understand machine-level representation and data manipulation and understand how a computer executes programs. One example is a recent macOS High Sierra root login bug that can be understood at the assembly level! If you're interested, put on your assembly hat and check out this walkthrough of the issue.
How can we ensure that our systems and networks are secure? - take CS155!
How can we design internet services that are worthy of trust? - take CS152!

Ethics, privacy, partiality and trust were woven through our quarter. Interested in exploring these topics in greater depth?

Why is privacy important? What technical and policy standards should we strive for in protecting privacy? - take CS182!
How can we recognize ethically important decisions as they arise? What policies ought we to adopt to address these issues? - take CS181!

Here's a list of courses, some mentioned in other tabs and some not that, based on your interest in the different parts of the CS107 material, you may like to take next. Most have CS107 as a prerequisite:

CS108: Object-Oriented Systems Design (prereq. CS107)
CS111: Operating Systems Principles (prereq. CS107)
CS112: Operating systems kernel implementation project (prereq. CS111)
CS124: From Languages To Information (prereq. CS106B)
CS140 / CS212 : Operating Systems and Systems Programming (prereq. CS110/CS111)
CS142: Web Applications (prereq. CS107 and CS108)
CS143: Compilers (prereq. CS107 and CS103)
CS144: Introduction to Computer Networking (prereq. CS110/CS111)
CS145: Data Management and Data Systems (prereq. CS107 and CS103)
CS148: Introduction to Computer Graphics and Imaging (prereq. CS107 and Math 51)
CS152: Trust and Safety Engineering (prereq. CS106B)
CS155: Computer and Network Security (prereq. CS110/CS111)
CS166: Data Structures (prereq. CS107 and CS161)
CS181: Computers, Ethics, and Public Policy (prereq. CS106A)
CS182: Ethics, Public Policy, and Technological Change (prereq. CS106A)
CS221: Artificial Intelligence: Principles and Techniques (prereq. CS106B, CS103, CS109, CS161)
CS242: Programming Languages (prereq. CS103, CS110/CS111)
CS246: Mining Massive Datasets (prereq. CS107 or CS145)
EE108: Digital System Design
EE180: Digital Systems Architecture (prereq. CS107 and recommended EE108)

CS107 - Connections With Future Material