CS 207.02 F17 Syllabus


If you have any disability that requires accommodations, please speak with me as soon as possible so we can figure out how I can best facilitate your learning in this course. Note that you will also need to provide documentation of your disability to the Dean for Student Academic Support and Advising, John Hirschman, located on the 3rd floor of the Rosenfield Center (x3089).


In order to design a computer program that solves a particular problem, we must model the problem in such a way that we can express it in our program. To model such a problem, we divide it up into data and key operations that manipulate that data. In a computer program, we realize these two things as data structures and algorithms over those data structures.

In this course, we discuss the set of fundamental data structures and algorithms used in most computer programs. These data structures are complex enough on their own that we would like to build and reason them about them independently from our main program. To this, we must also build effective abstractions that separate a data structure implementation from how it is used by the rest of our program. This need gives us a convenient opportunity to study the object-oriented programming paradigm and the Java programming language as object-orientation provides excellent mechanisms for defining abstractions between components of a program.

In summary, after this course, you will be able to:

  1. Write small-to-medium scale programs in Java that use the Collections facilities provided by its standard library.
  2. Implement and use fundamental data structures and algorithms found in most computer programs.
  3. Reason about two critical properties of computer programs—correctness and complexity.


In this course, we will use the following services to relay pertinent course information to you:

  • Piazza (link TBD) will be where announcements are posted and where you must ask all questions.
  • Github, a Git repository hosting service.

Please make sure that you are signed up for these services to stay up-to-date with the course.


There are no required textbooks for this course. Course readings will be provided through the schedule on the course website. For additional resources on the topics presented in this course, please consult the resource page. If you would like to purchase a textbook reference, here are some recommendations:


“Programming is not a spectator sport”, so the course features a variety of activities designed to get you actively manipulating definitions, drawing diagrams, and writing programs.

  • Readings: For every day of class, I will give you a short reading to prepare you for topic-of-the-day. Each reading is accompanied by a small exercise that you must turn in before class begins.
  • Lab: We will use the bulk of the class time each day to work on problems—both written and coding exercises—to help get the day’s concepts under your fingertips. Most of these labs will contain written assignments—code or written mathematics—that will be checked by the instructor or mentors in-class. They are due at the end of the class period. You will work on these problems in pairs to help facilitate peer learning, and I will assign new pairs every day to keep things fresh.
  • Homework: In addition to daily lab exercises, I will also assign weekly homeworks designed to expand on the topics we have discussed in class. The homework is also designed to be completed with a partner that will be randomly assigned to you every week.
  • Exams: Finally, to ensure that you have adequately mastered the core concepts of the class, I will conduct two examinations throughout the semester and a final. The exams and the final are held in-class and during finals week, respectively, and are individually assigned.


My goal in the course is for everyone to be proficient in the three big concepts outlined in the Overview—core Java programming, program analysis, and knowledge of fundamental data structures and algorithms. While this is a lot of content, I firmly believe that everyone is capable of mastering this material—earning an A in the process—with enough time, dedication, and proper study skills. Consequently, your grade in the course is determined by the following breakdown:

  • Reading: 10%
  • Labs: 10%
  • Homeworks: 45%
  • Exam #1: 10%
  • Exam #2: 10%
  • The final: 15%

For the reading quizzes and lab assignments, we will assess you on a simple three point scale:

  • 0: not completed
  • 1: completed but with significant errors
  • 2: completed with minor or no errors

The grading scale for homeworks will be more detailed to allow for us to assess your work in a variety of dimensions, e.g., correctness and coding style.

We will use the following scale to determine your final grade in the course:

  • A: 93–100%
  • A-: 90–93%
  • B+: 86–90%
  • B: 82-86%
  • B-: 78–82%
  • C+: 74–78%
  • C: 68–74%
  • D: 55–68%
  • F: 0–55%

If you obtain the (weighted) percentages of points listed above, you are guaranteed at least the corresponding grade. There is no curve in this course.

Extra Credit

To encourage you to get more involved with the material, the class, and the greater computer science community, we will provide opportunities for extra credit. These include:

  1. Challenge problems on the homework.
  2. Attending weekly CS events, e.g., CS Table on Tuesdays and CS Extras on Thursdays.
  3. Participation on Piazza.

These opportunities will give you a small amount of extra credit (read: one or two homework points). To avoid excessive gains with extra credit, I will cap your extra credit at the end of the semester such that you can only gain at most one half letter grade (i.e., minus to neutral, neutral to plus, plus to next-letter-up) due to extra credit.

Deadlines and Late Work

Homework is due at precisely 10:30pm on the date specified unless otherwise noted. This will usually be Mondays.

Because of the pace of the course, you will need to stay on top of the reading and lab work. Late reading and lab assignments will not be accepted unless you give prior notification before the deadline that you cannot turn in the lab due to absence for an event, illness, or other exceptional circumstances. In the event of such circumstances, please contact the instructor immediately to resolve the situation.

For homeworks, we will use a late day policy to help you manage your work load throughout the semester. This policy works as follows:

  • You have 7 late days to use in the semester.
  • You may use one late day to turn in one homework up to 24 hours after the due date, no questions asked.
  • You do not need to tell us that you are using a late day. Late days are automatically noted and tracked by the course staff.
  • You may use up to two late days on a given homework.
  • If you are working in a group, at least one member in the group must have a late day in order to extend the deadline by 24 hours. In this situation, the member with a late day burns one late day; the other member does not burn any (because they do not have any to burn).
  • Regardless of the number of late days you have, all homework is ultimately due at 10:30 PM on the final day of class.

Beyond late days, homework may not be turned in after the due date. This is a strict policy in order to help us get your feedback to you in a timely manner. Only the most exceptional of circumstances discussed well in advance with the instructor (as much as the situation allows) will be entertained.

Help and Academic Honesty

To help expedite your learning, we provide a number of outlets for help in this course:

  1. Myself,
  2. The course mentors,
  3. Lab tutors, and
  4. Your peers

Utilizing discussion with others to facilitate your own learning is a critical skill for success in computer science. To this end, we allow the following forms of collaboration:

  • When working with a partner, you are free to discuss all aspects of the assignment (lab or homework)—your work is their work.
  • When working with the mentors or a tutor, you are free to discuss high-level concepts about the assignment or get assistance in debugging your program. Questions about debugging should be short—as a rule of thumb, you should limit your question to a single error or a small region of problematic code such a single loop or a small function.
  • When working with other students, you are free to discuss high-level concepts about the assignment. However, unlike mentors and tutors, you should not receive help in debugging your program from other students to avoid the likelihood of copying code (intentional or not).
  • You may consult outside sources, e.g., Stack Overflow, for help with high-level concepts about the assignment or debugging your program.

In this course, we will use Piazza, an online Q&A web service (think “message board”), to facilitate discussion. When using Piazza:

  • If have a general question that can be answered by a fellow student (e.g., clarification on what the homework is asking, question about how an algorithm should work on a particular example), then post the question to everyone.
  • Otherwise (e.g., you have a specific question about the code you write), post the question to the instructors.
  • You may post questions to your fellow students or the instructors anonymously. If this feature is abused, it will be disabled. The point is for you to ask those questions that you are afraid will sound ‘stupid’. Better to ask!

In all cases, the work that you produce should be your own. The golden rule is that if I accidentally deleted your assignment, you should be able to reproduce it live with minimal effort. Furthermore in your submission you should cite all sources that you consult and what they helped you with in order to help make clear what aspects of the work are your own. Details of how to report this information (usually through a comment or README file) will be given for each lab and homework.