Rice University logo
Top blue bar image Comp215: Introduction to Program Design
Prof. Dan Wallach, Fall 2019

Course Syllabus



Comp215’s purpose is to introduce you, the student, to a variety of useful techniques in the world of computer science. We will assume that you have taken Comp140 and Comp182 at Rice or their equivalents, and thus have a familiarity with Python programming and with a variety of basic algorithms. We do not assume any prior experience with Java, although many of you will have seen some Java in high school. In Comp215, you will learn:

  • Java11 (which is, in many respects, quite a different language from Java7 and earlier)
  • Functional programming (a disciplined approach to building quality software)
  • Object-oriented programming (how and when it’s appropriate)
  • Unit tests, property-based tests, and other tools / techniques to test and debug your software
  • Performance: making your code fast, and how Java manages things under the hood
  • A variety of useful algorithms and data structures (e.g., balanced binary trees, regular expressions, genetic algorithms)
  • Software engineering: managing the process of building and extending software projects

Comp215 is structured with one project and one lab per week. You will work on the projects on your own in the first half of the class, then we will transition to working with partners in the second half. Projects are assigned Monday morning in class and they’re due Sunday evening at 11:59pm unless otherwise specified. Labs are done in person with the expectation that you’ll be able to finish your lab assignment in the one hour given. The first 8 weeks of class are really designed to get you up to speed with Java programming, culminating in you implementing a recursive-descent parser. After that, we’ll transition to some larger projects that will give you more freedom to design and write code yourself, plus you will learn a bit about building web applications. Those projects will still have weekly deadlines, even though a single project may span multiple weeks. In some weeks, we will also have smaller “side projects” on topics that don’t necessarily fit into the main projects but are still valuable for you to explore.

Comp215 will have two written exams: a midterm (given in the evening, date to be determined) and a final (given during the final exam period).


Sadly, despite there being hundreds of textbooks aiming at classes just like ours that use earlier versions of Java, there are no books like that for Java8 or later. Instead, the Java8 or later books on the market are generally intended to teach skilled Java7 programmers how to use the new features of Java8 or later. That’s not what you need. Consequently, you’ll have lecture notes and slides, sample code and lots of labbies and TAs.

You may choose to read Effective Java (3rd Edition) by Joshua Bloch, just released in 2018 and updated for Java8. (The differences between Java8 and Java11 aren’t a big deal with respect to reading this book.) Effective Java is not at all an introductory book for Java, but it does express many of the different programming rules and design ideas that we use in Comp215. Many of the same rules are expressed in Java For Small Teams, by Henry Coles and other contributors, available freely online.

We’ll be using the Git version control system, for which a wide variety of online advice is available (e.g., Commit Often, Perfect Later, Publish Once: Git Best Practices). We won’t be getting into any of the really advanced features of Git, which only come into play when you have multiple developers working simultaneously.

Lectures and Labs

Comp215’s lecture meets in Herring 100. Please be on-time; we’ll start promptly, and the beginning is when we tend to have announcements that you’d rather not miss. Most lectures will have corresponding slides that will appear on Piazza.

Comp215 also has labs. When you enrolled for Comp215, you enrolled in one of the four sections, each of which has a corresponding lab time. You attend one lab per week. If you do not finish in the hour provided, that’s fine. Any labbie can check you off, but only until Friday evening of the week the lab was assigned. See also, how partnering works, below.

The lab schedule:

  • Tuesday 1-2pm: SST 106
  • Tuesday, 4-5pm, Humanities 117
  • Wednesday 1-2pm and 4-5pm: Humanities 117

If you wish to change your lab section, please discuss it with Prof. Wallach. In particular, we have many more people in the Wednesday 1-2pm section than in all the others, so if you want to change out of Wednesday 1-2pm, that’s great.

Some labs involve coding, while others involve written quizzes. If you miss a written quiz, you won’t get the credit. Lab times are also used to resolve all of the partners for a given week (see below). If you cannot make your assigned lab section in any given week, please contact Prof. Wallach in advance.

Resources and Materials

We will use a variety of online resources to help you with Comp215. In particular:

  • comp215.blogs.rice.edu: This course syllabus and related public-facing materials will appear on our course web site.
  • Piazza: This will be the online discussion forum for Comp215. Course staff will monitor the group and do their best to answer your questions; of course you can also help each other out here (but see the “plagiarism and cheating” section below). We will also post PDF versions of the lecture slides, projects, and labs on Piazza. Please don’t share these outside of the classroom because we’re likely to reuse them from year to year. We expect you to read Piazza daily. If we need to make timely announcements, such as if we must relocate the class for a day, or if extenuating circumstances require moving deadlines around, that announcement will occur on Piazza.
  • canvas.rice.edu: We’ll use Canvas to get your grades back to you. We don’t use any of the other Canvas features.
  • github.com: We’ll use the Github service for a variety of things. When we provide “template” code for you to fill out, you’ll be downloading it from GitHub. As you’re working, you’ll be “committing and pushing” your changes to GitHub. Your final “push” will be treated as your submission for an assignment. (Additional issues related to this are discussed below.)

You’re required to have your own laptop running Windows, Mac OS X, or Linux. You will use your laptop in person for your labs. If you also have a desktop computer, you may use that as well, but at least in the beginning please stick with the laptop; there are some subtle ways that Git can trip you up when you use multiple computers. Also, many Rice classrooms do not have enough power outlets for everybody. Please make a habit of charging up your laptop in advance.

If having a suitable laptop computer represents a financial hardship for you, please let us know as soon as possible, and we will try to make suitable arrangements.

Staff and Office Hours

  • Dan Wallach’s office hours: DH 1081 (ground floor, north side of the building), F 3-5pm
  • TAs will have a variety of office hours, typically later in the evening, and will announce their availability on Piazza. When deadlines are approaching, we’ll try to always have one or more TAs and labbies logged into Piazza to respond in real-time to your questions.

Surveys / Experiments

This semester we will be conducting a research study looking at teaching and learning. The purpose of this study is to determine the factors that influence teaching effectiveness and learning.  Your participation in this study will last for the duration of the current semester and will entail activities no different from the regular activities you would otherwise engage in as part of the course. If you would like more information, please do not hesitate to ask.

Comp215 students will fill out three surveys, in approximately weeks 1, 8, and 15. Completion of these surveys is mandatory. Each survey will have its own deadline. The second two surveys will have a short window to respond, roughly 48 hours, so pay attention to the Piazza notifications. Each survey is worth a point, all or nothing, for its timely completion.

If you wish to opt-out of the survey process, you may instead choose to write a six-page essay summarizing one or more research papers on computer science pedagogy (i.e., the science of teaching computer science). This essay is due on the final day of regular classes. To exercise this option, you must notify Dr. Wallach within the first three weeks of class, and we will help you select suitable research papers.

We will also have a one-week “experiment” where you will be assigned a project as usual, but we will experimentally vary the project from student to student. You must do your project, as with any weekly project, but you will be given a grade for participation rather than a grade for correct completion of the project. This is subject to the same opt-out policy described above. Details of this experimental project will be announced later in the semester.

Independent of the surveys, from which you may opt out as described above, there will also be a quiz on this syllabus. That will be assigned in the second week of class and will happen on Canvas.


There will be a midterm exam and a final exam and, on most weeks, there will be one project and one lab. These will be weighted as follows:

  • Weekly programming projects: 60% (see details below)
  • Weekly labs: 10%
  • Exams (midterm and final, weighted equally): 25%
  • Surveys: 3%
  • Syllabus quiz: 2%

Comp215 has a strict late-work policy. Late work is not accepted! Because you will be working with partners in many assignments, we cannot offer any slack on this.

There will not be any “extra credit”, but if you do something above and beyond, we reserve the right to give you “cool points”. Those sorts of opportunities will arise more often in the second half of the semester than the first.

The weekly programming projects will each have their own grading rubrics, typically ten points. These will be equally weighted toward the total weight listed above. Of note, in some weeks we will add “side projects” to the weekly project. Side projects are graded at the same time as your “main” projects, but have different plagiarism policies (see below).

Lab points are all-or-nothing. Labbies will “check you off” during the lab time. For coding labs, we’re willing to do check-offs as late as Friday evening, 11:59pm, but no later.

Based on your final weighted average, we will assign letter grades as follows:

  • [80,83) is a B-, [83,87) is a B, [87,90) is a B+, [90,93) is an A-, etc.
  • We might curve up. We won’t curve down.
  • The curve is evaluated once, at the very end of the semester, once we have all the raw grading complete.

Grading disputes. Occasionally, you may wish to take issue with how you’ve been graded. Do not dispute your grade with your labbies! Our dispute resolution policy is:

  • Grade disputes must be submitted, in email, to Dr. Wallach with the subject line “Comp215: grade dispute, week[N] project” or “Comp215: grade dispute, [midterm/final] exam”. Include enough information in your email that Dr. Wallach can read it over and make a judgement without needing to pull your code up. Similarly, don’t just send a pile of Java files as email attachments. Instead, you’re writing an essay. For projects, quote relevant parts of your code, the feedback you got from your grader, and specify what sort of resolution you would prefer. For exams, you might attach a photo or scan of the page(s) in question. If your request is incomplete or incomprehensible, you will be denied. You may submit exactly one dispute per project or exam. If we deny it, that’s the end.
  • Consequently, we suggest talking to us in advance of dispute submissions, so we can give you guidance as to how likely your dispute is to succeed and what sorts of evidence you might provide.
  • Grade disputes must be submitted within one week of when you receive your grade for the given exam or project.
  • The only exception to this process will be if there is a “clerical error”, where your grader clearly made an error in a mechanical process, such as when copying a number from the autograder into Canvas. You may directly contact your grader to resolve clerical errors, if you wish, or you may contact Dr. Wallach. If your grader feels that your request is beyond the scope of a clerical error, they will instruct you to contact Dr. Wallach instead.

The specifics for how grades are assigned to your projects will generally be spelled out in the project handouts. You can expect that the bulk of your grade will come from your code being “correct” in the sense that it compiles and runs without errors, passing all of the tests that we’ve provided you, plus other tests that we might keep to ourselves or require you to write on your own.

Checking out and submitting your work

For each week’s project, you will receive a special URL that allows you to create a GitHub-hosted clone of our code where you’ll be doing your work. We will give you instructions for how to use Git (the version control system) and GitHub (the cloud service that supports Git). Our expectation is that you will commit and push your work early and often to the GitHub service. If we see that your commit messages have no meaningful explanation of your work, or if we see everything show up in one or two commits right before the deadline, you’ll lose points.

By visiting the GitHub web pages corresponding to your project, you’ll be able to verify that your code was safely submitted. In addition, we’ll be using a related service, GitHub Actions, to run your unit tests in the cloud and you’ll see the results of those tests in your list of commits. The results should be identical to what you see when you run the same tests locally. Be warned that those cloud servers might run slowly, especially close to a deadline, so don’t rely on them as a substitute for running your tests locally and following our Git/GitHub instructions!

Lastly, we note that there is no other supported mechanism for submitting your work. Everything will go through GitHub. We will never accept emailed code. Code on your local computer that you forgot to push to GitHub will not be accepted as a submission.

Group projects

Starting roughly in the seventh week of Comp215, you will begin working in teams of two students on your projects. We will teach you techniques and tactics to help you make the most of your partnerships. 

Partnerships will be assigned from within the same lab section, and you will partner with any other student at most once, unless Dr. Wallach otherwise gives you specific permission to the contrary.

As part of doing each week’s lab, we will make sure that you have a partner. Generally speaking, we will try to let you pick your own partners, but we also want to ensure that nobody repeats a partnership.

If you cannot attend your assigned lab section due to a time conflict, but you can attend an alternative section, we may permit this, or we may simply tell you who you’ll be partnering with. If you simply don’t arrive at your lab section without prior notice, you cannot rely on us to ensure you have a partner. You’re responsible for following up, and then we’ll do our best to accomodate you.

Teams of three: We will only allow one team of three in a given section, and then only if we have an odd number of students. You will be in a group of three at most once in the semester.

Intercollegiate competitions: Comp215 students compete in a variety of activities that draw them away from campus. Please make us aware of your obligations, and of any other students who may share the same obligations. If it’s sensible, we may have you work together.

Dropping the course while working with a partner: Most of the group projects will occur after the university’s drop deadline, but you have an ethical responsibility to your partner beyond what we can enforce in Comp215. Simply put, don’t drop the course and leave your partner hanging. Even if it’s allowed by the university, it’s a huge source of stress to your partner.

Questionnaires: After each project is complete, we will have a short and optional partner questionnaire. We will provide you with these hyperlinks and you will be asked one or two short questions about your partner. These questionnaires help us to understand, over time, who is being helpful and who is flaking.

Flaking partners: Part of working with a partner is being responsive to emails, scheduling the necessary time together, and jointly beginning your work early enough that you can reach a realistic understanding of how much time it will take to complete the project. If one of you is diligently trying to do this and your partner is unresponsive, please contact Dr. Wallach immediately. These cases will be handled on a case by case basis, with remedies that may include splitting and rearrangement of partnerships, or unequal grades given to each partner. Partnering is a privilege. If you abuse the privilege, you will be assigned later projects solo.

Plagiarism and Cheating

Let’s be clear: plagiarism is not acceptable. Be aware that we will use sophisticated tools to detect plagiarism and cases of plagiarism will be referred to the Rice Honor Council. To that end, let’s spell out what constitutes acceptable vs. unacceptable behavior.

  • The Internet is full of amazing resources, like StackOverflow, where all sorts of technical questions are asked and answered. You may not post a question directly relating to a Comp215 assignment on any online forum beyond our private Piazza forum. Soliciting external assistance constitutes cheating, whether or not you get a useful answer. That being said, if you wish to post a question in public that’s not related to Comp215, such as trying to understand how to configure IntelliJ’s fonts or screen colors, this isn’t a problem.
  • We encourage you to treat the broader Internet as a “read-only” source of information related to the course. Our exams will be “open-Internet”, in the sense that you’re welcome to type any query to Google and use that to help you understand what you’re doing. However, writing a question or communicating with a colleague on the Internet is no different than doing it in person and represents cheating.
  • On “open-Internet” exams, you may not use IntelliJ, Eclipse, or any other code development environment. You may not run “javac” or any other Java compiler. You may not use any other programming language tools. You may look at your existing code, or our provided reference code, using other tools (e.g., visiting your GitHub web pages) in a read-only fashion. Why? We may ask questions of the form “what does this program print as its output?” which would be trivial to answer if you could run the Java compiler. This rule requires you to be able to understand how things work.
  • For your projects and labs, you may find Internet resources that have partial or maybe even complete written solutions to your specific assignment. Use of these specific resources in any fashion constitutes plagiarism, except for the following caveats:
    • If you found inspiration in some Internet web page providing generally useful advice or code which is not a partial or complete solution to your assignment, you must cite your sources, typically by placing relevant URLs in comments in your code. We encourage you to share helpful URLs with your colleagues via Piazza. If you’re not sure whether some Internet resource is acceptable, ask a labbie or your instructor first.
    • You may directly copy at most two lines of code from any given Internet source. You must still cite your sources.
    • If you wish to use a larger block of code (or a complete library) from the Internet, that is only acceptable if the code block or library is a general-purpose tool unrelated to the specific goals of an assignment. For example, if we are having you implement a pretty pictures generator, where the goals of the assignment are for you to design the relevant data structures and algorithms for generating and combining pictures, we won’t have a problem with you using an external library that somehow lets you have cool fonts or a fancy webpage design to display your pictures; you must still cite it properly.
  • Copying and then trivially rewriting larger blocks of code (e.g., changing variable names, comments, indentation, or other forms of refactoring) is treated the same as if you directly copied the original code. Be aware that our plagiarism tools are very good at detecting this sort of thing and your attempts to obfuscate your violation will hurt you later.
  • Also be aware that we will compare this year’s submissions to solutions from prior years. If you submit work that’s not your own, we will detect it and we will refer both you and the original author to the Honor Council. Generally speaking, you are forbidden from consulting any computer code, written notes, or even classroom slides from prior years’ Comp215. Why? Later weeks’ slides may discuss solutions to prior week’s projects. If you look at last year’s slides, you may find solutions to your project work.

Collaboration. While it is common for Rice students in some classes to speak to one another and look over one another’s shoulders, perhaps with one student giving another a guided explanation of how to solve a problem, this is not acceptable for Comp215. You (and your partner, when working with partners later in the semester) are expected to submit your own work, not the work of your peers. That said, our labs and “side projects” are designed to encourage discussion with your peers. The rules below should help clarify things for you.

Always / never:

  • Keep your hands off of your colleagues’ computers.
  • Don’t share your credentials for GitHub or other online services.
  • Don’t cut-and-paste code into email, Piazza, or any other form of sharing including reading it aloud. (Private instructor-visible-only posts to Piazza are fine.)
  • It’s fine to walk somebody else through your hand-written lecture notes, the online slides, or the reference code that we provide you.

When asking a current Comp215 student for help on a project:

  • Put away your computers and printouts.
  • Don’t just freehand the solutions on a whiteboard, piece of paper, or other communication.
  • Talk about the challenges, but don’t solve the problems for your peers.
  • Talk about analogous or simpler problems and how those might be solved.

When asking a former Comp215 student or a labbie/TA for help on a project:

  • They must put away their own computers and printouts, but they may look at yours. 
  • This implies they may not say “just a minute, let me check how I solved this last year.”
  • They may not share prior years’ code with you in any fashion.
  • They can talk about the challenges they faced, but they cannot solve your problems for you.
  • They can talk about how they solved analogous or simpler problems.
  • A former student or labbie who violates this rule is also violating the Honor Code.

If you failed Comp215 in a prior year and are repeating the class:

  • You may never look at our reference solutions from prior years.
  • For specific Comp215 projects for which you were previously found responsible for plagiarism by the Honor Council, you may not look at or otherwise use your prior years’ submissions.
  • In our experience, students who re-do all of the assignments from scratch are much more likely to succeed in the course; this is what we strongly recommend.

For “side projects” and “labs”:

  • In most weeks, we will have a lab session. In some weeks, we will have additional “side projects”. In these circumstances, we encourage you to first attempt the problem on your own (or with your partner, in weeks where you have a partner) before seeking assistance from others.
  • If you’re stuck, it’s okay to ask others for help.
  • If you’re being asked for help, don’t just describe the complete solution. Ask good questions in return. Try to lead your friends to find the solution on their own. You want to make sure your peers understand the problem, rather than just getting it working without understanding why.

Cite your sources. This might be code you might find on the Internet which is unrelated to the project requirements, so it’s allowed. This also includes assistance that you receive from a labbie or TA, where they gave you an idea or insight that helped you solve a problem. Uncited sources of any kind are a violation of the Honor Code. Example: you and a friend went to a labbie’s office hours who then gave you a useful insight; you then both independently implemented it. If you both have a code comment with the name of the labbie, the date you were there, and what you learned, and if you satisfied everything else here, then you’re fine. Conversely, if we discover you having an identical solution and you don’t cite any sources, we will take this as evidence of you having an unauthorized collaboration and will report you to the Honor Council.

(Why all these rules? Because we want you to put the pieces together and solve the problem. If somebody else shows you the answer and you copy it, then you learned nothing. Unfortunately, we need rules like these because some students in the past have chosen plagiarism instead.)

Committing early and often. It’s good software engineering practice to “commit and push” your changes to the central repository on a regular basis. This way, if you make a mistake, it’s easy to roll back to an earlier version, and if your computer fails, you don’t lose any of your work. Indeed, your grade for most weeks’ projects will include points for this. This good engineering practice also has the side effect that we, your instructors, can see the entire history of your work: when you made each change along the way from the start to the completion of your work. We will use this information to help us decide plagiarism cases. If, for example, your code appears all at once and seems very similar to another student for whom we have a stream of commits, we will take that as evidence that you didn’t do the work and that you copied from your colleague. (Both of you, in this case, would be reported to the Rice Honor Council as having violated this policy.)

Git / GitHub specifics. We will give you detailed instructions on how to properly “commit” your code and “push” it to GitHub, and we expect you will do both of these actions simultaneously. GitHub provides us with precise timestamps for each time you push your code. When we’re distinguishing “on-time” vs. “late” submissions, these “push” timestamps are what we’ll use. In other words, if you roll back the clock on your computer and fake your commit times, we’ll still see your real push times, and will determine “lateness” in this fashion. If we see a large group of “commits” arrive in a single “push”, this will also be treated as a sign of potential plagiarism.

Future sharing. Lastly, we must speak to your responsibilities with respect to prior and future students of Comp215. We expect to reuse some assignments from year to year. Therefore:

  • You must not post your project or lab solutions online in any publicly accessible fashion (e.g., on a public GitHub repository; the GitHub pages you will be using for the class will be private).
  • You must not post the reference code for the “edu.rice” package that we provide you, nor anything you may derive from our reference code,  online in a publicly accessible fashion.
  • And, you may neither look for nor use prior class year’s solutions to Comp215 in any fashion whatsoever.
    • If you’re otherwise enamored with the reusable library code that we create in Comp215, we’ll happily point you to open-source alternatives.
    • If a job recruiter wants to see your work, that’s acceptable, but you may not use a public sharing mechanism like GitHub.
  • This requirement also includes our slides, handouts, prior exams (with or without solutions), and any other materials we provide you, unless we explicitly say otherwise.
  • We will use plagiarism detection tools that compare your work to our reference code as well as your colleagues from this and past years. Future students’ work will be compared to yours as well.

If we detect that you’re sharing your code in any fashion, even in future years after you’ve completed Comp215, we will still report you to the Rice Honor Council and your grade may be retroactively reduced. Keep your Comp215 solutions to yourself.

Late Work Policy

Every weekly project is due Sunday at 11:59pm, with the subsequent project typically coming out Monday morning. That doesn’t leave much room for slack. Consequently, we have a strict late work policy. We don’t accept late work. The deadline is the deadline. We encourage you to get started early! If we see that you have pushed a solution to GitHub beyond the deadline, we will roll the clock back to the latest commit that you pushed before the deadline. (The time at which you “commit” your work locally is ignored. What matters is when you “push” your code to GitHub.)

If you can anticipate, in advance, being unable to complete you work prior to a deadline, email your instructors and we will do our best to accommodate your needs. If, for example, you provide us with documentation for travel requirements related to intercollegiate competitions, we’ll do our best to accommodate your needs. On the other hand, if you have job interviews or personal travel, it’s your responsibility to schedule your personal life around your academic responsibilities.

If, however, you show up on Monday and beg for forgiveness, we are likely to deny your request. In particular, any request based on a medical condition must be accompanied by a doctor’s note or an equivalent communication from your college magister. We will not take your word for it. 

If you must leave on short notice for unplanned issues (family emergencies, etc.), notify us immediately and we will do our best to accommodate your needs. Include relevant documentation (plane tickets, funeral announcements, etc.). We understand that notifying your instructors while dealing with such issues can be frustrating and is necessarily a low priority for you, but we also need to ensure that other students don’t abuse these policies. This is especially important when you’re working with a partner, who must then also be accomodated.

Rescheduling exams. We generally wish to post solutions to our exams as quickly as possible. To that end, it’s important that students all sit for the same exam at the same time. Our midterm exam will be scheduled in an evening time block and our final exam will be scheduled by the registrar during the finals period. As a general rule, we’re only willing to allow you to reschedule the exam if the source of your time conflict, being aware of our exam schedule, writes us a letter requiring your presence at that specific time. Your exams are more important than your job interviews or your desire to get home early for the holidays, and you should prioritize them appropriately.

The cone of silence. If we do approve a late assignment submission or an unusual exam time, understand that it’s a major imposition on the course staff and upon every other student in the class. You must not look at any code that we or other students might provide, after the original deadline, which you could have used to solve your problem. You must not discuss it with other students in class who might tell you such information. The use of any such materials would constitute a flagrant violation of our Plagiarism and Cheating policies.