CSC 207 Spring 2018 Syllabus


Class Time/Location:

MWF 8:30-9:50, Noyce 3820


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). If you do not have documentation for your disability for whatever reason, please still speak with me.


It’s time for you to become a real computer scientist!

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 do 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 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. For each reading you will be required to record a reading journal that summarizes the main concepts of the reading in your own words.
  • 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 mentor 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 Journal: 10%
  • Labs: 10%
  • Homeworks: 45%
  • Exam #1: 10%
  • Exam #2: 10%
  • The final: 15%

For the reading journal and lab assignments, I 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 me to assess your work in a variety of dimensions, e.g., correctness and coding style.

I 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.

To receive these points:

  1. Your README must state the extra credit that your did for the homework
  2. You must email me within one week of the event and report on what was discussed
  3. Piazza allows you to answer other students’ questions. I will note correct student answers and they will receive extra credit.

Deadlines and Late Work

Homework is due at precisely 5pm 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.
  • Your group 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). Basically interpret this as the most generous way of using up late days.
  • 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, following the debugging rules below.
  • When working with other students, you are free to discuss high-level concepts about the assignment and limited debugging based on the debugging rules.
  • 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. Never post code publicly.
  • 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 (without your partner!). 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. Report sources in either comments or your README.

Debugging Rules

Learning how to debug effectively and efficiently is a pillar of being a real computer scientist. To that end, you will be expected to make a significant effort debugging any code before you may get help from me or a mentor/tutor/another student. When asking for help, you must:

  1. Be able to articulate what the error is. Logical errors are when your program isn’t giving a correct result; syntactic are when your program won’t compile.
    1. For logical errors, you must have specific input that your program doesn’t perform correctly and what the correct result should be. This should be as simple of a test case as possible to recreate the bug.
    2. For syntactic problems, you must copy the exact error message and Google/search-engine-of-choice it. I will ask to see what resources you have already consulted, since they help me figure out your bug too!
  2. Be able to say exactly where your error is occurring. There are many debugging tools you can use to do this, including GDB and break-points. The simplest approach is to put a whole lot of print statements in your code to identify exactly what line it crashes on or exactly what the values of the variables are at every step. Your print statements should be descriptive so that I can walk through your programs logic from the print statements alone.

If you ask the mentor or I to help with a bug and can’t show these two steps, we will tell you to complete them before we’ll help. It is true that you will likely have bugs that we can spot immediately, but you don’t learn how to debug yourself when we just fix the problem for you.