|Exam Type||Download Links|
|Regular Seating Mon. 7-9PM||Regular Exam|
|Remote or alternate 2-hour exam||Alternate Exam|
|OAE 150% extra time||OAE Exam|
Note: We unfortunately currently don't have a way for students to access their own submissions from the electronic practice exam. If you'd like to compare your answers to the posted solutions, please make sure to copy, save, or otherwise keep your answers before submitting. Apologies for some of the growing pains as we develop all of the functionality of our new electronic exam system!
Section Handouts and CodeStepByStep lecture practice problems (on the schedule page) are also great ways to practice relevant material.
The exam is administered on a digital tool called BlueBook. Please make sure to download and install BlueBook on your laptop before the exam.
Note: If you're using a Mac and you get an error saying that the Disk Image is from an unidentified developer, don't panic! Simply open up the
Mac-BlueBook-1.0.0.dmg file in your finder, and right click it and select "Open."" The same window will pop up, but this time you'll have a chance to open it anyway. On Windows, if you get a message that says, "Windows protected your PC," you can click on "More info" and then "Run anyway."
A practice exam that can be run on BlueBook can be downloaded above. This exam will be run under timed conditions, and give you an idea of what to expect for the actual exam.
Should you run into any technical issues, post on Piazza or shoot the BlueBook team an email at email@example.com.
The exam is on your computer but otherwise closed-book and closed-notes. You should bring:
Your laptop and charger
The device you use for two-step authentication
Two double-sided sheets of notes
A power strip / extension cord (optional, but recommended if you have access to one)
If you don't have a working laptop let us know AS SOON AS POSSIBLE and we will get you set up with one.
The Honor Code: the exam is to be completed individually and without any assistance from a partner or other students. Follow the Stanford Honor Code (see handout #2 in the Handouts dropdown) during the exam: submit only your own work, do not use unpermitted aids on the exam (see below for permitted aids), and say something to the instructors or students in question to prevent any inappropriate activity conducted by others surrounding the exam.
A syntax reference sheet will be provided during the exam (a sample is linked here for reference)
You are not permitted to use any other materials, such as textbooks, printouts (notes beyond two sheets, slides, code, practice exams, etc.), or electronic devices (iPads, Kindles, calculators, music players, etc.). You may only have BlueBook open on your computer. Any use of unpermitted materials will result in an immediate Honor Code violation.
Grading: Unless a question specifically mentions otherwise, the code you write will be graded purely on functionality (proper behavior and output) and not on style. For instance, redundancy, variable names, commenting and decomposition will not impact your score. However, we still encourage you to use good style in your code, as it often makes the solutions easier to write (and modify if needed).
Note that certain problems may have certain constraints (such as only using certain material, etc.) that you must follow to earn full credit. We reserve the right to deduct points for extremely inelegant or inefficient code that dodges the spirit of the problem.
You are not required to write
import statements on the exam. Please do not abbreviate any code on the exam (such as writing "x2" next to code to copy it twice). Abbreviated code will not be graded.
Pseudo-code (writing English sentences and phrases instead of code) will typically earn little to no points. For example, writing "In this part of the code, I want to open the file and read each line and print it" will not earn any points.
The midterm will cover all material up to the midterm (the Snowman assignment and all lectures/sections the week of July 16). This includes the following concepts listed below. Note that you may be asked to read code (look at a piece of existing code and answer questions about it, such as writing its output) and/or write code (write a piece of code such as a method or short program that solves a given problem).
Karel the Robot: given a piece of Java code that gives instructions to Karel the Robot, evaluate it and describe the resulting state of Karel's world; and/or, write a complete Karel program to accomplish a given result in Karel's world.
ConsolePrograms: write Java code to perform console input/output using Stanford's libraries (readInt, println, etc.)
Java Control Statements: given a piece of Java code using Java statements like
if/else, etc., evaluate it and write its output/results; and/or, write Java code that uses Java control statements to solve a problem.
Expressions and Variables: given some Java expressions with numbers, strings, logic, etc., evaluate them and write the results; and/or, write Java code that uses expressions and operators to solve a problem.
Methods, Parameters, and Return: given a piece of Java code with several methods and parameters/returns, evaluate it and write its output/results; and/or, write Java methods that accept various parameters and/or return certain values.
RandomGenerator: write Java code exhibiting random behavior using the RandomGenerator class.
char: given a piece of Java code that interacts with text, evaluate it and write its output/results; and/or, write Java code that processes strings and characters to produce a given result.
Scanner and File Processing: write Java code that uses a Scanner (and try/catch) to read data from a file in a given format and produce a particular result.
GraphicsPrograms: write Java code to implement a graphics program with certain behavior using Stanford's libraries; this may include drawing shapes such as GRect, GOval, etc., animation, and/or handling mouse events.
The following concepts will NOT be tested on the midterm:
Graphical shapes not used in lecture/section, such as
converting numbers to/from other bases, such as binary or hexadecimal
do loops and the
continue statement (
while loops may be needed, though)
throwing exceptions with the
any Stanford library functionality not explicitly taught in class, section or homeworks
anything else not explicitly covered in lecture, section or homeworks
Hopefully you have been keeping up in lecture and doing well on the assignments, but may be unsure of how to make sure your skills will translate well to the exam setting. The practice midterm above gives an idea of what to expect, but we also want to provide some general advice for how to prepare and approach the exam.
You will be taking your exam using software called BlueBook. Electronic exams hold several advantages. For students, writing code on a computer (with syntax highlighting, undo, cut, etc) is a much easier exam experience than writing solutions out by hand. The way in which you are assessed is much closer to the way in which you program. The logistics become much easier for students with disability accommodations and students who are taking the course from off campus. On our end, it makes it a lot easier to make, distribute and grade exams. Instead of using the 16,000 pages of paper that CS106A typically consumes each year we use 0. Finally, grading hand written exams is hard and inaccurate. Hand written exams allow for bias in teachers' grading and are inaccurate because we can’t run your programs. Your midterm will still be assessed by a human, but they will be better equipped to understand what you were trying to do.
Great it’s on a computer! Why can’t I run my program? In a time-restricted situation, immediate feedback from the compiler can be more of an impediment than an advantage. Imagine this, you read the first problem, have a good idea how to solve it, write your solution, and trace its operation and feel good. You compile and test it. Suppose it exhibits a bug—even though it may only be a minor issue, you can see your answer is wrong—so you hunker down and rework and retest until perfect... even if it takes the whole exam. Bad deal – since you never got to the other problems on the exam! We want you to write your best answer and move on.
We know that BlueBook is not the same as working with a compiler, and we account for that in how we design and grade the exam. We are assessing your ability to think logically and use appropriate problem-solving techniques. We expect you to express yourself in reasonably correct Java, but we will be lenient with errors that are syntactic rather than conceptual.
Make a cheatsheet, but don't depend on it. We allow two double-sided "cheatsheets" of notes during the exam. Making a cheatsheet involves a thorough review of all course material, which will make you better consolidate information and identify gaps in your understanding. However, we don’t expect you to memorize minute details and the exam will not focus on them. To do well, you must be experienced at working through problems efficiently and accurately, without needing to repeatedly refer to your cheatsheets.
Practice, practice, practice. A good way to study for the programming problems is to take a problem (lecture or section example, chapter exercise, sample exam problem) and write out your solution under test-like conditions (e.g., on blank paper or a text editor not in Eclipse, with a short amount of time). Don't fall into the trap of just practicing your exam problems in Eclipse, which compiles your code and provides immediate feedback that you won't have on the real exam. You want to practice under real exam conditions to become comfortable writing code in a timed setting. This is much more valuable than simply reviewing the exam, looking at the answers, and understanding why they are correct - a much different (and simpler) task than having to write the solutions yourself.
Get your questions answered. If there is a concept you’re a bit fuzzy on, or you’d like to check your answer to something, or you wonder why a solution is written a particular way, swing by the LaIR, come to office hours, find Colin or Annie before/after any lecture, or email your Section Leader/grader; we are happy to help.
Scan the entire exam first. Quickly peruse all questions before starting on any one. This allows you to “multitask” — while working on one problem, your mind can be brainstorming strategies or ideas for another problem in the background. You can also sketch out how to allocate your time between questions in the first pass. Speaking of which...
Spend your time wisely. There are only a handful of questions, and each is worth a significant amount. Don’t get stuck on any particular problem. There is much opportunity for partial credit, so it’s better to make good efforts on all problems than to perfect an answer to one leaving others untouched.
Consider the point value of each question. Divide the total minutes by the total number of points to figure the time per point and use that as guide when allocating your time across the problems. You may want to reserve a little time for checking your work at the end as well.
Style and decomposition are secondary to correctness. Unlike the assignments where we hold you to high standards in all areas, for an exam, unless a question explicitly says otherwise, your responses will only be graded on functionality. Decomposition and style are thus somewhat de-emphasized. However, good design may make it easier for you to get the functionality correct and require less code, which takes less time and has fewer opportunities for errors. Moreover, when a solution is incorrect, good stylistic practices such as commenting may help us determine what you were trying to do and award partial credit.
Answer in pseudo-code, but only if you must. If the syntax of Java is somehow in your way, you can answer in pseudo-code ("code-like English") for a very small amount of partial credit. There is a wide variation in the scoring for pseudo-code. Some pseudo-code is vague and content-less and does little more than restate the problem description, and thus is worth next to nothing. The more details it provides, the better. But truthfully, very good pseudo-code contains so much information that it typically would have been easier and more concise to just write in Java in the first place.
Pay attention to specific instructions. A problem statement may include detailed constraints and hints such as “Karel must end up facing East.” You may want to underline or highlight these instructions to be sure you don’t overlook them. These constraints are not there to make things more difficult; typically we are trying to guide you in the direction of a straightforward and simple solution. If you disregard these instructions, you are likely to lose points, either for not meeting the problem specification and/or for errors introduced when attempting a more difficult alternative.
Syntax is not that important if it is clear what you mean. We won't trouble you about most small syntax errors (forgetting semi-colons, misspellings, etc.) as long as your intentions are clear. Having said that, if your syntax errors cause ambiguity, we might not get the correct meaning. For example, if we see a for statement followed by two lines, where both lines are vaguely indented or a third line has been added in after the fact, but you forgot curly braces, we may be confused. If there are braces around all the lines, it will be clear you intended both to be a part of the loop body, but without the braces, we can’t be sure and it may make your answer incorrect.
Comment out abandoned attempts rather than deleting them. As it usually turns out on a CS exam, you will have false starts on a problem — you try one strategy and hit a dead end. You try something else and then realize you actually were closer to the right solution the first time. If you haven’t erased your first attempt, you can always go back to it. Once you work out a better answer, comment out your earlier attempt. When you comment out work, please direct us to which solution you want graded instead. If you forget to comment out your bad attempt and hence appear to have two answers, we reserve the right to pick which one to grade.
Save a little time for checking your work. Before submitting your exam, reserve a few minutes to go back over your work. Check for missing initialization/return statements, correct parameters passed to functions, etc. You might save yourself a few lost points by tidying up the details at the end.
Download the exam ahead of time. The exam will be posted Sunday night. Download the encrypted exam before you come to the midterm so that you are ready to go when the test starts.
Prepare your laptop. We will have outlets available, but not nearly enough for everyone. Come with a laptop that has enough battery for 2 hours. If you need battery it would be useful for you to bring your own power strip. Make sure your computer isn’t just about to run out of memory.
Always remember why you are at school. Learning and education tend to be a more fulfilling goal than just high grades. If you work hard, study lots, and feel good about your understanding of computer science, that is an achievement to be proud of in itself — regardless of how many points you get relative to the other students in the class. Moreover, for most (if not all) of you, this is your first exam ever in computer science; taking an exam in a brand-new subject doesn't happen very often! Use this first and foremost as a "litmus test" of sorts to see how you are doing midway through the class, what you are understanding well, and what you can improve in future homework assignments and on the final exam. The midterm is not worth a huge chunk of your grade, and there is still plenty of time to improve. Remember that computer science is not an easy endeavor, even for experienced computer scientists.