Skip to content

15213 Course Goals (Chinese Version)

Original excerpt from https://www.cs.cmu.edu/afs/cs.cmu.edu/academic/class/15213-m23/www/ (course syllabus)

This course aims to make you a better programmer by introducing the basic concepts common to all computer systems. We want you to understand what happens when programs run, so that when things go wrong (and they eventually will), you have the mental ability to solve the problem.

Most of the time you write programs in high-level languages — why understand the underlying computer system? In CS, we mostly use abstractions and think within the frameworks they provide. But every abstraction ignores something, and sometimes what's ignored becomes critically important. As an analogy, Newtonian mechanics ignores relativistic effects. For low-speed objects (under 0.1c), the Newtonian abstraction is perfect. But at higher speeds we need more detail.

The following "realities" are scenarios where the abstractions you learned no longer apply:

  1. The "int" type isn't mathematical integer; "float" isn't mathematical real. We represent numbers with finite bits, and this limitation matters a lot. Sometimes we must consider how bits represent integers and floats.
  2. You must know some assembly. You may never write programs in assembly, but sometimes program behavior just can't be explained purely at the high-level abstraction. Also, being familiar with machine-level computational models helps understand the effects of some bugs.
  3. Memory matters. Computer memory isn't infinite; it must be allocated and managed carefully. Memory-reference errors have serious consequences. An error accessing one struct can modify another logically unrelated struct. Also, cache and virtual memory provide a logically infinite address space, but not "infinite memory" performance.
  4. Program performance isn't just asymptotic complexity. Constant factors matter. There's a systematic way to evaluate and optimize performance.
  5. Computers don't just execute instructions. They also perform I/O, and interact with other systems over networks.

After this course, you'll have a deeper understanding of these "realities," preparing you for more advanced systems courses in CMU's EECS program. More importantly, you'll learn knowledge and skills that benefit you throughout your career.

Concretely, we set the following learning goals; after the course you should be able to:

  1. Explain the binary representation of common data types (unsigned, two's complement, floating point) and the mathematical properties of related arithmetic and bit operations.
  2. Recognize the relationship between C-language programs and assembly-language representations, including expressions, control flow, functions, and data structures.
  3. Understand the basic intent of a program from its binary representation, and apply this to debugging.
  4. Understand how programmers interact with the underlying system via different APIs and abstractions, including processes and threads, virtual memory, and network system support.
  5. Analyze the consequences of flawed system operation, e.g. poor memory/CPU performance, crashes, and security vulnerabilities.
  6. Apply standard and custom tools to assist development, including compilers, code analyzers, debuggers, consistency checkers, and performance-analysis tools.
  7. Apply these analytical and tool skills to different components of modern computer systems to write reliable, efficient programs.
  8. Understand conflicts that can occur in multi-threaded execution of shared resources, and use some synchronization to resolve them.