It's time for a computing exam wooo! View this not as an intimidating obstacle to be overcome, but a chance at reflection to see how much you've learned and where your gaps of knowledge may be.

Here's how this is going to go:

• The "exam" will be largely programmatic with some conceptual elements to test your understanding of the material.

• The exam will take the place and time of the usual lecture (see the course syllabus) but will last only 90 minutes.

The exam is CLOSED note and CLOSED computer. You may NOT collaborate with peers or any other person during the duration of the exam.

You are allowed to bring ONE 8.5" x 11" (double sided) cheat sheet with any information you'd like with you for consultation into the exam.

The exam may feel long, but that's OK! Take your time, a deep breath or two, and don't worry if you don't finish everything -- it will be likely that your classmates do not either, which will likely be by design.

The exam does not have a forced curve (i.e., that only some set number of people can receive A's, B's, etc.), but it WILL have a difficulty adjustment (upward bonus) if it was too hard.

Exam I will cover the topics in the first half of the class. These include:

• Java programming: instances vs. classes (and relatedly: non-static vs. static fields / methods), class design, access modifiers, inheritance, abstract vs. concrete classes, interfaces, inner-classes, objects vs. primitives, references, tests for equivalence, Object superclass, overriding methods.

• Memory architecture: garbage collection, memory management, dynamic allocation, stack vs. heap in memory, references within this context, how to draw variables in stack and heap.

• Data structures: distinction from Abstract Data Types (Lists, Stacks, Queues), interface vs. implementation.

• ArrayLists: dynamically sized array, implementation details, operations that ArrayLists handle well and which they handle poorly, distinction from primitive arrays.

• LinkedLists: Node-based references, implementation details, operations that LinkedLists handle well and which they handle poorly.

• Stacks & Queues: FILO vs. FIFO ordering, operations, different implementations possible for each, use cases.

• Java Collections Framework: generics, ArrayLists, LinkedLists, Stacks, Queues.

• Class Examples: Forneymon, IntList, IntArrayList, IntLinkedList, IntStack, Forneymonagerie, and all classwork exercises. Any may be referenced or expanded upon during the exam.

The examination format may include:

• Vocabulary and fill-in-the-blank questions

• Multiple choice

• Understanding drawings of objects, arrays, references

• Structured-response code writing (I give you a skeleton, you fill in the requested parts)

Be prepared to answer some questions similar to those on the assignments and in-class exercises.

Furthermore, although I won't ask you anything about mechanics we haven't covered in class, you might be expected to apply the mechanics we've learned about in a way that we didn't see in class. If you thoroughly understand the material, there should be no surprises, but still challenges.

Here is my suggestion for preparation order:

1. Re-read my course notes, re-doing the exercises if you aren't clear on any of them.

2. Study any available classwork and homework solutions.

3. Consult the syllabus' recommended extra-practice sites for problems on topics that you're still unfamiliar with; there are plenty for all of our data structures.

4. Still not confident on a topic? Feel free to ping on Slack and ask anything, including requests for questions / specifications on a particular problem type.