Exams

Final Details

Final Logistics

The final will be a written exam held on Wednesday December 10th from 12:30 PM to 2:20 PM in Bagley Hall 131.

If you absolutely cannot make the scheduled time for the exam, let your instructors know as soon as possible in a private Ed post.

Final Policy

The final will be a written exam. The exam will be closed book, except that you may have two 5x8 (or smaller) index cards with whatever notes you wish written on both sides for reference. The notes must be hand-written, i.e., no computer printouts, no scanned/reduced notes, and no electronic devices or other technology.

The final exam will be biased towards content not tested on the midterm, but but anything we've done this quarter could appear, so you should also review topics on the midterm list.

You should understand the ideas and core concepts and how to use them, but don't memorize API details. We'll provide hints or reference material on the exam for API details as needed, but you should know the basics.

If you absolutely cannot make the scheduled time for the exam, let your instructors know as soon as possible in a private Ed post.

Previous Final Exams

Note: summer final exams are 1 hour long compared to 1:50 during the regular year. The topics are generally the same so all of the old exams should be useful for review.

Final Topics

This list summarizes topics we've covered since those on the midterm. The final exam will be biased towards these items but anything we've done this quarter could appear, so you should also review things on the midterm list. Generally, if you've kept up with everything that's been covered in lecture, sections, exercises, and homework assignments you should be well prepared, and questions may be based on any of the work we've done this quarter.

  • The rest of C++
    • Templates - template parameters for classes and functions, what happens when the compiler generates an instance of a template
    • STL, containers, and iterators. You are not expected to know picky details, but you should be able to use basic containers (vector, list, map) and iterators.
    • Smart pointers, reference counting semantics, using with STL. Understand differences between unique_ptr (cannot be copied, but can move ownership to another), shared_ptr (reference counting), weak_ptr (using to break cycles and why this is needed)
    • Subclasses, inheritance, virtual functions, dynamic vs static dispatch (function calls), vtables, constructors and destructors in subclasses
    • Pure virtual functions and abstract classes (what they are, how it works)
    • Using class heirarchies with STL and smart pointers, value vs pointer semantics, assignment slicing
    • C++ casts
  • Network Programming
    • Basic concepts of network layers: physical, data link, IP, TCP, application
    • Packets, and packet encapsulation across layers
    • IP addresses, address families (IPv4 and IPv6), DNS, ports
    • TCP stream sockets, file descriptors, read, write, close
    • Client steps: address resolution, create socket, connect socket to server, read/write (including retrys), close
    • Server steps: determine address and port, create socket, bind socket to address/port, listen (and how the OS queues pending connections and data), accept connection, read/write (including retrys), close
    • Very basic HTTP and HTML (e.g., understand data sent and received by something like the HW4 web server)
    • 🚫We will not expect you to know anything about the "Beyond sockets" portion of lecture 23
    • 🚫We will not expect you to know anything about Bill Joy's life or resume
  • Concurrency
    • Use of concurrency to improve throughput and resource utilization
    • Multiple processes and fork() (review of CSE351 mostly), shared resources including file descriptors and close() in forked processes
    • Threads - concurrent execution inside a single process; know some pthread basics (i.e., what it means to create a thread and start execution in a function; passing arguments to threads); basic issues involving sharing data between threads and locking.
  • OS Components and Organization
    • The responsibilities, lifetimes and privilige levels of the boot loader, kernel, init system, daemons and shells
    • File permissions: What "RWX" permissions mean and how they are used
    • 🚫We will not expect you to know what each folder in the root filesystem ("/") is for
    • 🚫We will not expect you to know anything about containerization or OS-level namespaces

Midterm Details

Midterm Results

The median score for the midterm was 41.38 with a standard deviation of 10.48.
Sample solutions: Version A, Version B

Midterm Logistics

The midterm will be a written exam held on Monday October 27th from 5:30 PM to 6:20 PM in Smith Hall 120.

If you absolutely cannot make the scheduled time for the exam, let your instructors know as soon as possible in a private Ed post.

Midterm Policy

The midterm will be a written exam. The exam will be closed book, except that you may have one 5x8 (or smaller) index card with whatever notes you wish written on both sides for reference. The notes must be hand-written, i.e., no computer printouts, no scanned/reduced notes, and no electronic devices or other technology.

You should understand the ideas and core concepts and how to use them, but don't memorize API details. We'll provide hints or reference material on the exam for API details as needed, but you should know the basics.

If you absolutely cannot make the scheduled time for the exam, let your instructors know as soon as possible in a private Ed post.

Previous exams

Midterm Topics

The midterm will cover content up through (and including) C++ templates. Knowledge of topics covered after that will not be expected in the exam.

  • General program organization and where C fits in the ecosystem
    • System layers: C language, libraries, and operating system
    • General workflow needed to build a program – preprocessor, compile, link
    • Preprocessor – how #include, #define, #ifndef and other basic commands rewrite the program
    • Structure of C/C++ programs: header files, source files
      • Declarations vs definitions
      • Organization and use of header files, including #ifndef guards
      • Faking modularity in C – headers, implementations
      • Internal vs external linkage; use of static for internal linkage
      • Dependencies – what needs to be recompiled when something changes (dependency graph behind make and similar tools)
      • More tools: basics of using git for version control (add/commit/push, primarily), what to put in a repository and what to leave out
      • More tools: be able to read and interpret basic valgrind output and use it to identify memory bugs in programs
  • C language and program execution
    • Review: standard types, operators, functions, scope, parameters, strings, etc.
    • Extended integer types (int32_t, uint64_t, etc.) and when to use them
    • Standard I/O library and streams: stdin, stdout, fopen, fread, scanf, printf, fwrite, etc.
    • POSIX libraries – wrappers for system calls
      • POSIX-layer I/O: open, read, write, etc.; basics of directory reading API
      • Relationship between C standard library, POSIX library functions, and system calls
    • Error handling - error codes and errno; error handling/retry for POSIX read/write
    • Process address space and memory map (code, static data, heap, stack)
      • Object lifetimes: static, automatic, dynamic (heap)
      • Stack and function calls – what happens during function call, return; stack frames
    • Function parameters
      • Call by value semantics (including structs, pointers)
      • Arrays as parameters - pointers
      • Using pointers to approximate call-by-reference semantics
      • Function pointers as parameters
    • Pointers, pointers, pointers - &, *, and all that
      • Typing rules and pointer arithmetic (what does p+1 mean?)
      • Relationship between pointers and arrays, a[i] and pointer arithmetic *(a+i)
      • String constants, arrays of characters, C string library
      • Using void* as a “generic” pointer type
      • Casting
      • Dynamic allocation (malloc, free)
      • Potential bugs – memory leaks, dangling pointers (including returning pointers to local data), etc.
      • Be able to draw and read diagrams showing storage and pointers, and be able to trace code that manipulates these things
    • Structs – how to define and use; meaning of p->x ( = (*p).x ); structs as local variables, parameters, and return values (value semantics) vs. heap-allocated structs; struct values vs pointers to structs
    • Typedef – how to define and use
    • Linked data structures in C – linked lists, hash tables, etc.
    • Data structures and operations from the course projects (hw1, hw2) (copies of header files will be provided as needed if the exam includes specific questions about project code)
  • C++
    • Classes and modularity, namespaces
      • Be able to read and create simple class definitions and add to them, implement functions, trace code, etc.
      • Know the difference between constructors, copy constructors, and assignment and when these are executed
      • Know what a destructor is and when it gets executed and what it should do
    • Other basic differences from C
      • Simpler, type-safe stream I/O (cout, cin, <<, and >>)
      • Type-safe memory management (new, delete, delete[ ])
      • References – particularly reference parameters
      • More pervasive use of const (const data and parameters, const member functions)
    • Templates
      • Basics of templates - template parameters for classes and functions, when templates are expanded with actual types, templates and header files.