Final Exam

Online in Gradescope, 3 hours, December 17–20

The final will be taken online in Gradescope. It will contain both short answer / multiple choice and a few longer questions that require you to write code.

You will have three hours to complete the exam. To permit flexibility in your schedule, you may take the exam at any point between 12:00 noon EST Friday 12/17 and 10:00 PM EST Monday 12/20. Please be sure that you finish the exam by 10:00 PM EST on Monday, and that you take time-zone differences into account if you are not at Princeton.

Moreover, please be aware that instructors will be available to answer clarifying questions (via a private message on Ed) during a limited set of hours:

• Friday, 12/17, 12:00 noon – 10:00 PM EST
• Saturday, 12/18, 7:00 PM – 10:00 PM EST
• Sunday, 12/19, 7:00 PM – 10:00 PM EST
• Monday, 12/20, 10:00 AM – 10:00 PM EST

Once you begin the exam, you must complete it in one contiguous 3-hour session. Gradescope will display the time remaining - when time runs out, it will end the exam. (Your answers are autosaved as you enter them, though we don't recommend answering questions until the very last second...)

Rules

This will be a closed-book, closed-note exam, and "cheat sheets" are not allowed. During the exam you must not refer to the textbook, course materials, notes, or any information on the Internet. You may not compile or run any code on armlab or any other machine. The exam will emphasize application of concepts and not memorization, so you will be provided with information such as manual pages, C operator precedence tables, AARCH64 register descriptions and assembly/machine language instructions, etc. if they are necessary.

You are not allowed to communicate with any other person, whether inside or outside the class, for the entire duration of the exam. You may not send the exam problems to anyone, nor receive them from anyone, nor communicate any information about the problems or their topics. Staff will not answer questions concerning the course content after 12:00 noon Friday.

You will be required to type out and sign an honor code pledge that you did not use any unauthorized sources of information during the exam.

Topics

You will be responsible for material from the entire course, including the content of required readings, lectures, precepts, and assignments. All questions will assume the ArmLab/Linux/C90/gcc217 environment unless otherwise stated. The second half of the course (since the midterm) will be emphasized.

Major topics include (topics since the midterm in blue):

1. Number Systems
   • Binary, octal, hexadecimal number systems
   • Unsigned integers: finite representation and operations
   • Signed integers: finite two's complement representation and operations
   • Overflow
2. C Programming
   • The program preparation process: preprocess, compile, assemble, link
   • Program structure: multi-file programs using header files
   • Statements
   • Operators
   • Input/output of standard streams and files, for text and binary data: getchar(), fgetc(), putchar(), fputc(), gets(), fgets(), puts(), fputs(), scanf(), fscanf(), printf(), fprintf(), fopen(), fclose(), fwrite(), putc()
   • Data types
   • Variable declarations and definitions, including scope, linkage, and duration / extent
   • Process memory layout: text, stack, heap, rodata, data, bss sections
   • Constants: #define, constant variables, enumerations
   • Function declarations and definitions
   • Arrays and pointers, call by reference, arrays as parameters, strings
   • Command-line arguments
   • Structures
   • Dynamic memory management: malloc(), calloc(), realloc(), and free()
   • Common memory/pointer errors: dereference of NULL, dereference of dangling pointer, memory leak, double free
   • Generic data structures and functions, void pointers, function pointers
3. Under the hood: language levels
   • High-level languages vs assembly language vs machine language
   • Von Neumann computer architecture, RAM, CPU, ALU, registers
   • Little-endian vs big-endian byte order
   • AARCH64 architecture: general-purpose and special registers
   • AARCH64 assembly language: directives, labels, load/store/manipulation instructions, control flow
   • Accessing variables in data, rodata, bss, and stack
   • Accessing array and struct variables; addressing modes
   • AARCH64 function call conventions: bl and ret instructions, the x30 register, arguments, return values
   • AARCH64 local variables: on stack vs in callee-saved registers
   • AARCH64 machine language: instruction formats, layout after assembly, layout after linking
4. Programming techniques and tools
   • git and source code management
   • make and build management
   • Testing
   • gdb and debugging, including for assembly language
   • Profiling with gprof
   • Optimization
   • objdump
   • Data structures: linked lists, hash tables, dynamically expanding arrays
   • Abstract data types and objects
   • Deterministic finite-state automata (DFA)
   • Symbol tables, directory and file trees, bigint addition, buffer overrun
   • Modularity, separation of interface and implementation

Questions from Previous Semesters

A good way to practice for the exam is to go over questions from previous COS 217 final exams. Be aware that both the content of the course and the format of the final do change over the years, so not all questions are guaranteed to be 100% relevant, or good practice for this year. If you have any questions about whether the content of a question would be fair game for this year, please ask on Ed.

• Sample questions and answers
• Exclusions - questions on topics we haven't covered
• Topics index for the sample questions (final exams are in the second tab)

Review and Q&A

There will be a review and Q&A session on Thursday, December 16 from 10:00 AM through noon, in Friend 101. The session will be recorded, and you are welcome to submit questions ahead of time by posting them on Ed.

Watch this space and Ed for any additional announcements.