| CPSC 120 | Principles of Computer Science | Fall 2024 |
The final exam will be cumulative. It will include the material covered on the two midterms, plus the following new topics:
See the review guides for the two midterms for specifics on that material.
Behavioral animation (boids), images, and advanced topics like particle systems will not be covered.
The exam will be in the registrar-scheduled timeslot (Wednesday 12/11 1:30-4:30pm). If you have three finals on the same day, you may ask your dean and your professor to move one of them. This should be done now — don't wait until the last minute! Finals cannot generally be rescheduled or made up for other reasons without approval of your dean.
Unless it is an emergency, you may not leave the room during the exam. (You can, of course, hand in the exam and leave if you finish early.) Plan ahead — use the bathroom and take care of any other necessary business before the exam.
You may use a single page of notes (8.5x11", one side). This page may be handwritten or typed and can contain whatever you would like, but it must be a hardcopy — printed or written on a piece of paper — and must be personally prepared by you — you may not copy another student's notes or make copies of your own for others.
Expect the exam to be about twice as long as a midterm — it is not intended to take the full three-hour timeslot, but you will have the whole time to work if you wish.
As with the midterms, the final exam will be written (not on the computer) and closed book except for a single page of notes as described above.
Most questions will involve writing Processing code to achieve a particular result, similar to the in-class exercises. You should be able to recognize when animation, interaction, functions, conditionals (including particular conditionals patterns), loops (including particular loop patterns), and arrays are applicable and be able to identify key elements such as which animation variables, loop variables, or function parameters are needed. You may be asked about those things directly (similar to #4 on exam 2) or indirectly (you'll just be asked to write code for a sketch, and you'll need to know what constructs to use).
You may also be asked to modify some provided code, describe what some code will do when run, figure out sizes and coordinates for shapes in a scene, or define and/or give examples of the "principles" terms listed above (algorithm, representation, decomposition, etc).
You are expected to have correct syntax in your answers, however, because you don't have the computer to point out problems, there is some leniency — small syntax errors such as the occasional missed semicolon will not be penalized. (However, frequent mistakes of the same type or large errors that indicate a lack of understanding will lose points as these types of problems are impediments to producing a successful program.)
The best way to study for the exam is to practice as much as you can. If you have not completed any exercises from the labs or the projects during the semester, complete them. (And hand them in!) The in-class exercises are also a good for practice — work on ones you didn't get to or didn't finish in class. Start by trying to do the problems yourself, then go to office hours and/or Teaching Fellows for help if needed. Stick to the materials from class posted on the course webpage — don't use the Internet to look for other resources to help you. (Some solutions for in-class problems are posted. Don't look at them until after you've tried to solve the problem, and keep in mind that there can be more than one way to solve a problem — use the solutions as an example of a correct answer, not the only correct answer.)
Keep in mind that the key takeaway from this course should be the process of constructing programs — it's not about any particular end result, but rather knowing what to do to get there. Review the slides from class and in particular things like the conditionals and loops questions — these help you identify what to use to accomplish a task, and how to fill in the particular constructs.