Exam Details

Author

Steven Bogaerts

General Information

All exams this semester will be taken at the Engineering Testing Facility(opens in new tab) (ETF). Instead of everyone taking the exam at the same time, each exam will be offered over a range of dates and times. You will sign up ahead of time for a specific 1-hour block (50 minutes of actual test-taking time) at the ETF.

Note

I have tried to make this page as complete and accurate as possible. Please note that this information is subject to change as the exam date approaches.

ETF Policies and Procedures

Please be certain that you read all the ETF documentation for students(opens in new tab). Note the important links to additional pages on the left: Location, Making a Reservation, etc.

Warning

It is very important that you read all of the documentation at the ETF site! Note, for example, what items are / are not allowed, bathroom policy (no bathroom allowed for 50-minute tests unless you have an SSD accommodation), etc. I’ll also mention that if you miss your appointment, a retake opportunity is not guaranteed, so please work very hard to not let that happen! Read the ETF site for details, and reach out to course staff via the EECS 183 Admin Form if there’s an issue with your appointment.

Also please note:

  • Policies: The policies of the ETF are the policies of this course, and academic integrity infractions related to the ETF are infractions in this course.
  • SSD Accommodations: The ETF strives to support all students and offers accommodations as outlined by Student Accessibility and Accommodations Services (SAAS). The ETF is well prepared to support most common accommodations. See the SSD Accommodations section of the ETF website(opens in new tab) for details.
    • At least a couple weeks before the exam, verify that any expected accommodations are in place. You can check this on the PrairieTest site(opens in new tab). If you have any concerns, please reach out to the ETF at etf-support@umich.edu. They have a record of all accommodations approved by SAAS. Of course, also feel free to fill out the EECS 183 Admin Form if you need assistance from EECS 183 staff.
  • Reservations: Reservations for an exam start about two weeks before the beginning of the exam window. The sections below and the EECS 183 course calendar show when sign up begins for each exam. You will need to have joined our class on PrairieTest (see Tools Registration) in order to sign up for an exam.
Note

The dates for each exam are shown in the sections below and on the main course calendar. Since each exam is offered over a range of dates, we expect that in nearly all cases every student will be able to take the exam at some time within that range. If you know of a reason that will not be possible for you, you must request an alternative no later than the listed exam signup start day by filling out the Admin Form. (The earlier the request, the better.) Approval is not guaranteed, and we will need documentation of your need to consider your request.

Questions or Concerns During the Exam

The ETF documentation for students(opens in new tab) describes how to handle various problems that may arise. In short, if you have any issues during an exam, inform the facilitator immediately. Work with the facilitator to resolve the issue at the time before logging off. If you do not inform a facilitator of a problem during the test, we will not be able to address it after the fact.

Here are some additional details specific to our course:

  • If you want to ask about a question during the exam:

    • Our response to questions during the exam is always the same:

      Everything you need to answer the question is provided in the problem description. If you think there is an error in the question, read it again carefully and do your best to answer the question as you understand it. If you still believe there is an error after re-reading, you may report an error in the question if you wish, in which case we’ll review it after the exam.

    • We do extensive testing of the exams, so hopefully such errors will be rare or nonexistent. But you can report an error with the “Report an error in this question” option on the right sidebar for every question. Please do not use your exam time writing a lengthy report! Just put a phrase or two in the report so that it’s flagged for consideration. Even just one word if you’re really short on time. If we need more information, we’ll reach out to you after the exam. If you don’t hear from us and you’re concerned, please fill out the Admin Form after the exam.

    • Please note that, other than the quoted response above, we cannot provide any response to questions during the exam. The only exception is if you do not understand an ordinary non-CS-related English word. (This policy was in place even when we previously gave synchronous paper exams.)

  • If a question crashes:
    • Again, hopefully this will never happen because the questions are tested extensively.
    • If a question does crash, don’t worry. You should (1) notify the ETF exam facilitator immediately (see ETF documentation for details), and (2) complete the test the best you can. Course staff will receive reports from the ETF facilitator and automatically from PrairieLearn, and will work to resolve issues fairly.
    • If you believe you were graded unfairly because of some such issue, please feel free to reach out via the EECS 183 Admin Form.

How to Prepare for the Exams

  • The most important preparation is diligent almost-daily engagement with the material throughout the semester.
  • Come to the in-class and out-of-class review sessions for the exam. We plan to record these sessions and make them available on Canvas after the event.
  • Come to office hours to talk through concepts together.
  • Review lecture slides and redo provided practice problems.
  • Review lab section materials and assignments. Redo labs as needed.
  • Review zyBooks readings and redo activities for the lectures covered on the exam.
  • Redo PrairieLearn problems. You can still practice past assignments without it affecting your grade in any way.
  • Redo corresponding projects, or portions of them, as needed.
  • Work through the additional practice problems provided in the review lectures.
Tip

Make sure you’ve worked through the PrairieTest Tutorial as well! This will give you a very good idea of what to expect from the exam platform itself.

Question Types

  • Multiple choice and short answer: questions may include but are not limited to:
    • Code analysis, what gets printed, etc.
    • What line / few lines of code would accomplish a stated purpose
    • General concepts and vocabulary
    • Similar to the medium and harder difficulty PrairieLearn multiple choice questions.
  • Free Response: questions may include but are not limited to:
    • English explanation of some concept or program behavior
    • Fill in the blank(s) in code to accomplish some purpose
    • Write a larger amount of code (little or no “starter code” given)
    • Similar to PrairieLearn coding questions and in-class coding exercises.

Length

Each appointment at the ETF will be for 1 hour, but the actual work time on the exam will be 50 minutes.

Exam 1

  • Signup Begins: Monday, September 14
  • Extra Review Session: Sunday, September 27, 6 - 8 PM, CHEM 1400
  • Exam Dates: Monday, September 28 through Friday, October 2

Exam 1 will cover:

  • Lec01 through Lec08 (inclusive)
  • Project 1
  • Labs through Lab 3 (inclusive)
  • Pre01 through Pre07 (inclusive)
  • Post01 through Post07 (inclusive)

This exam will not include a reference sheet (“cheat sheet”).

  • Intro topics
    • print
    • math operators
    • Assignment
      • Increment, decrement
      • Assignment versus printing
    • Statement vs. expression
    • Calling a function, argument, operator, operand, value, (side) effect, grammar, syntax
    • Identifying and fixing syntax errors
    • Types - int, float, str
    • type function
    • Casting
    • Keyboard input
    • f-strings
    • /, //, and % Operators
    • abs (calling a built-in function, arguments)
    • Comments
    • import math, math.exp
    • floor, ceil
    • The Python interactive shell
  • Intro strings
    • str: len, indexing
    • n, escape sequences
  • Conditionals
    • bool
    • if statements
    • Relational operators (<, etc.)
    • and, or, not
    • if, elif, else
    • Nested
    • None, is None, is not None (otherwise use ==)
    • Implement a hard-coded decision tree
  • Defining a function (no arguments, no return type)
  • main function, and if __name__ == '__main__':
  • Vocabulary: class, instance, object
  • Lists, len, indexing, append, remove, pop, in
  • Negative indices (lists and strings)
  • Slicing (lists and strings)
  • Dot notation
  • Pop as an “expression” and a “statement”
  • Iteration:
    • for e in ls:
    • for c in s:
  • Short-circuited and, or
  • Functions
    • Writing a function that returns something
    • Parameters, comments, type annotations
    • Flow of control
    • RME
    • Type annotations for lists
    • Scope
    • Why functions?
    • Functions as a means of abstraction, for handling complexity
    • Avoiding code duplication, facilitating modification
    • Writing a function that doesn’t return anything
    • None and code like: x = funcThatDoesntReturn() and print(f"result={funcThatDoesntReturn()}")
    • Static type checking, type hints, | for union
    • Keyword arguments and default values
  • Iteration on Lists
    • Several fundamental 1-D list problems:
      • Accumulation: Sum of elements in a list
      • Calling one function from another: Average of elements (calling sum function)
      • If-guarded update of an accumulator: Max of elements
      • Count: Count the sixes
      • Make a new list: divide by constant
      • Lists of lists
      • Nested loops intuition
      • Sum of all
      • Sum for each row
      • Sum of rows meeting a criterion
      • Movie recommender

Exam 2

  • Signup Begins: Thursday, October 8
  • Extra Review Session: Wednesday, October 21, 6 - 8 PM, Angell Hall AUD C
  • Exam Dates: Thursday, October 22 through Wednesday, October 28

Exam 2 will be a cumulative exam, meaning that it could include questions on any material from exam 1 as well. However, the majority of exam 2 will focus on material covered after exam 1’s topics. Specifically, Exam 2 will focus on:

  • Lec09 through Lec15 (inclusive)
  • Project 2
  • Labs 4 and 5
  • Pre09 through Pre14 (inclusive)
  • Post09 through Post14 (inclusive)

This exam will include a reference sheet. This will be provided to you in electronic form in the ETF. If the sheet is updated before the exam, I will update this link and make an announcement on the main page of the course website accordingly.

  • Additional useful string methods:
    • lower, upper
    • isdigit, isalpha
    • lstrip, rstrip, strip
    • split, join
  • Sets
    • add, remove, in, iteration
  • Files
  • with open…
  • Handling newlines
  • try, except FileNotFoundError
  • Iteration on files (kind of like a list of lines)
    • One line at a time
    • One character at a time
    • One “word” at a time (with punctuation)
    • Processing numbers in a file (nested loops)
  • Writing to a file
  • Dictionaries
    • Constructing
    • Accessing (get, [ ])
    • Adding pairs
    • d.pop(key)
    • Iteration on dictionaries
    • for key in d.keys()
    • for value in d.values()
    • for key, value in d.items()
  • Mutation, Tuples, and Type Hints
    • Mutation versus assignment
    • Parameter passing and mutation of parameters
    • Tuples
    • Immutable list
    • Simultaneous assignment
    • Packing / unpacking
    • Special use in type hints
  • More Iteration Patterns
    • while loops: syntax, behavior, and difference from for loops (definite vs. indefinite)
    • Writing correct loop termination conditions (avoiding infinite loops)
    • zip: combining two or more iterables into an iterator of tuples, behavior when iterables have different lengths
    • Iterables vs. iterators (conceptual distinction)
    • Tuple unpacking in for loops with zip
    • zip, next, iterator consumption
    • enumerate, start
    • break, continue
    • Range
  • Comprehensions
    • List comprehensions: syntax and semantics
    • Set comprehensions
    • Dictionary comprehensions
    • Filtered comprehensions: adding conditional expressions to comprehensions
    • Equivalence between comprehensions and explicit for loops
    • assert
  • Numpy
    • Creating ndarray objects with np.array()
    • Array attributes: dtype, shape, ndim
    • Common dtypes: int64, float32, float64; conversion with astype() (does not mutate)
    • 1-D vs. 2-D arrays; interpreting shape tuples like (3,) vs. (3, 1) vs. (1, 3)
    • Elementwise arithmetic operators (e.g., array + scalar, array + array)
    • Indexing and slicing 1-D and 2-D arrays, including : (all rows/columns), c[row, col] syntax
    • Warning: NumPy slices are views (mutating a slice mutates the original), unlike Python list slices
    • aggregation and axis for 2-D numpy arrays
    • Numpy sum, min, max, mean, argmin, argmax
    • arange, linspace, zeros, ones, full, reshape
    • Numpy boolean indexing, including with &, |, ~
    • fromiter
  • Pandas
    • pd.read_csv(): just the basic use we’ve done in class
    • DataFrame structure: rows with integer index, named columns
    • Inspecting data: df.head(), df.shape, df.columns, df.index, df.info(), df.describe()
    • np.nan
    • loc, iloc; label versus position
    • :: for selecting all rows or all columns
    • Scalar, list, slice, and boolean indexers
    • Constructing a Series or DataFrame
    • sum, min, max, mean, idxmax, idxmin

Exam 3

  • Signup Begins: Monday, November 2
  • Extra Review Session: Sunday, November 15, 6 - 8 PM, CHEM 1400
  • Exam Dates: Monday, November 16 through Friday, November 20

Exam 3 will be a cumulative exam, meaning that it could include questions on any material from the entire semester. However, the majority of the exam will focus on material covered after exam 2’s topics. One exception to this is that, since Exam 2 includes some Pandas material, and Exam 3 includes more, please expect a more significant amount of Exam 2 Pandas material to appear again in some form for Exam 3.

Thus, Exam 3 will focus on:

  • Lec14, Lec16 through Lec21 (inclusive)
    • Lec15 was an exam 2 review, so in that sense it isn’t a “focus” of exam 3.
  • Project 3
  • Labs 6 through 8 (inclusive)
  • Pre18 and Pre20
  • Post14 through Post20 (inclusive)

This exam will include a reference sheet. This will be provided to you in electronic form in the ETF. If the sheet is updated before the exam, I will update this link and make an announcement on the main page of the course website accordingly.

  • Pandas
    • pd.read_csv(): just the basic use we’ve done in class
    • DataFrame structure: rows with integer index, named columns
    • Inspecting data: df.head(), df.shape, df.columns, df.index, df.info(), df.describe()
    • np.nan
    • loc, iloc; label versus position
    • :: for selecting all rows or all columns
    • Scalar, list, slice, and boolean indexers
    • Constructing a Series or DataFrame
    • sum, min, max, mean, idxmax, idxmin
    • df.loc[row, col] syntax for selecting and modifying values
    • Changing a single cell, an entire column, or adding a new column with df.loc
    • Adding a new row with df.loc
    • Boolean indexers: creating a boolean Series from a condition and using it to filter rows
    • Creating a Series with pd.Series(...)
    • Creating a DataFrame with pd.DataFrame(...)
    • Combining boolean conditions with & (and), | (or), ~ (not); required parentheses
    • Aggregating a Series: .sum, .mean, .min, .max, .median, .mode, .idxmin, .idxmax, .count, .value_counts
    • Same functions as above, with axis parameter, for a DataFrame
    • groupby - different forms
    • Vectorization, ufuncs
    • Series.map(dict): applying a dictionary lookup to every element; unmapped values become NaN
    • Series.map(func): applying a single-parameter function to every element
    • DataFrame.apply(func, axis=___): applying a function one Series at a time
    • Distinction between map (element-wise on a Series) and apply (row/column-wise on a DataFrame)
    • Nested functions as “throw-away” helpers for map/apply
    • isna, dropna, fillna: detecting, removing, and replacing missing values
    • isin: bool Series of membership
    • nlargest, nsmallest: selecting the top/bottom values of a Series or DataFrame
  • Classes
    • Classes, objects
    • __init__, self, other methods, attributes, __str__
    • Respecting the encapsulation
    • Collections (e.g., list) of objects
    • Defining a class that uses an instance of another class
    • Motivation for classes: managing state, encapsulating data with operations, protecting data from misuse (vs. a plain DataFrame approach)
  • Machine Learning
    • Supervised, reinforcement, and unsupervised learning: distinguishing the type of data and task given examples
    • Vocabulary: training set, testing set, model, algorithm, parameters, fit/train step, predictions
    • X_train, y_train, X_test, y_test, y_pred/y_hat/ground truth: what each represents and how they relate
    • Evaluating a model: comparing predictions on X_test to the ground truth y_test; computing accuracy
    • Linear regression: the model is a line (\hat{y} = w_0 + w_1 x); w_0 and w_1 as parameters to learn (fit) from training data
    • Making a prediction from a linear model given specific parameter values and an input x
    • Measuring how far a prediction is from the ground truth; squared error and why it’s preferred over plain difference (order doesn’t matter, penalizes big errors more)
    • Mean squared error (MSE): definition, formula, and how it aggregates error across a whole training set
    • Vectors: 1-D numpy array, math notations (angle brackets, column/row vectors, arrow notation)
    • Dot product: definition, how to compute it, and recognizing it as a 1-D numpy array multiply-then-sum
    • Rewriting w_0 + w_1 x_i as a dot product of parameter and input vectors
    • Matrices: 2-D numpy array, connecting math notation to a 2-D array
    • Building the augmented input matrix X (a column of 1’s plus the input column(s))
    • Matrix-vector multiplication (X @ w) as a vectorized way to compute predictions for an entire training/testing set at once
    • Using X @ w to compute MSE efficiently across all examples
    • The closed-form solution for the optimal weight vector w = (X^T X)^{-1} (X^T y); recognizing transpose and inverse notation (not deriving it)
    • Generalizing linear regression from one input variable to d input variables (extra columns in X and extra entries in w)

Academic Integrity and Solution Sharing

It is strictly prohibited to post, share, or otherwise distribute your solution code (in part or in full) in any manner or on any platform, public or private, where it may be accessed by anyone other than the course staff. This includes, but is not limited to:

  • Public-facing websites (like a personal blog or public GitHub repo).
  • Solution-sharing websites (like Chegg or Course Hero).
  • Private collections, archives, or repositories (such as student group test banks, club wikis, or shared Google Drives).
  • Group messaging platforms (like Discord or Slack).

Distributing your solutions is a violation of the university’s academic integrity policy and will be treated as such. Asking questions by posting small code snippets to our private course discussion forum is permitted and is not a violation of this policy.