Rice University logo
 
Top blue bar image Comp215: Introduction to Program Design
Dan Wallach and Zoran Budimlić, Fall 2018
 

Course Syllabus

 

(Note: You’re looking at a draft version of the syllabus for the Fall 2018 edition of Comp215. This text will change between now and when the course begins in August.)

Introduction

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:

  • Java8 (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, mock 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. They’re assigned Monday morning in class and they’re due Sunday evening at 11:59pm unless otherwise specified. Labs are done in person, again on your own, 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 Java8 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 sig 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).

Textbooks

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 books on the market are generally intended to teach skilled Java7 programmers how to use the new features of Java8. 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. 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 meets in room TBD. 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 three sections, each of which has a corresponding lab time. You attend one lab per week; you may go to a different lab session than the one in which you’re enrolled if need be, but space in the room is limited so we’d prefer you go to your assigned time. 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.

All labs are in room TBD:

  • Tuesday 4-5pm and 6-7pm
  • Wednesday 4-5pm

Some labs involve coding, while others involve written quizzes. If you miss a coding lab, or if you’re a hotshot and don’t feel like you need help, then you can just show up and get checked off. If you miss a written quiz, you won’t get the points. If you find yourself, in any given week, being unable to attend any of these lab times, please contact your instructors in advance and we’ll make custom arrangements for you.

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

Your instructors are Dan Wallach and Zoran Budimlić. Their office hours are:

  • Wallach, DH 1081 (ground floor, behind the coffee room), TBD
  • Budimlić, DH 3134 (third floor, in the administrative corridor), TBD
  • 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

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 2, 8, and 15. Completion of these surveys is mandatory. Each survey will have its own deadline, roughly 48 hours after its release. 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 your professors 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. You will also be able to opt-out of this. Details of the process will be announced later in the semester.

Grading

There will be a midterm exam and a final exam and, on most weeks, there will be one project and one lab. Projects will be graded out of ten points. Labs and side projects will be one point. Exams will be graded out of 100 points. These will be weighted as follows:

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

Comp215 has a strict late-work policy (detailed below; late work is not accepted). To give you some slack, we will drop your lowest project grade. In other words, you can skip any one week, but you should take care to save it for later in the semester if you really need it. Note that this does not apply to lab points or to “side project” points in weeks where we have side projects.

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.

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.

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

  • Grade disputes must be submitted, in email, to your professors with the subject line “Comp215: grade dispute, week[N] project” or “Comp215: grade dispute, [midterm/final] exam”. Include enough information in your email that your professors 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 or project.

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. Each project will have its own grading rubric which explains each week’s requirements. “Side projects”, in weeks that we have them, will be spelled out in your handouts, including their grading weights.

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 another service 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. Furthermore, code on your local computer that you forgot to push to GitHub will not be accepted as a submission.

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, where we have a strong history of winning sanctions against accused Comp215 students. 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 forumSoliciting 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 constitutes cheating on our exams.
  • 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 (emacs, vim, or 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.) Similarly, you may not use your computer to “draft” your solutions to exam questions. Computer screens are too easily seen by your peers.
  • 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 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. (Later weeks’ slides may discuss solutions to prior week’s projects.)

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. Comp215 is not a group-work class. You’re expected to do your work on your own. That said, our labs and “side projects” are designed to encourage discussion with your peers. The rules below should help clarify things for you.

For “projects”:

  • Keep your hands off of your colleagues’ computers.
  • Don’t ever share your credentials for GitHub or other online services.
  • Don’t cut-and-paste code into email, Piazza, or any other form of sharing.
  • It’s fine to walk somebody else through your hand-written lecture notes, the online slides, or the reference code that we provide you.
  • It’s forbidden to walk somebody else through your work-in-progress solutions to the current week’s main project. You may not even discuss your work until after the submission deadline.
  • Students repeating Comp215: If you failed Comp215 in a prior semester and are retaking the class, you may never look at our reference solutions from prior years. What’s more, you may not look at your old work on assignments where you were previously found responsible for plagiarism by the Honor Council. In our experience, students who re-do all of the assignments from scratch are much more likely to succeed in the course, so this is what we strongly recommend.
  • Interacting with labbies, TAs, and prior students: You are permitted to show your work to anyone who has successfully completed Comp215. Such people might look over your shoulder and offer advice to you, so long as they are not referring to their own code or our reference code. You may not allow another individual to write, type, or dictate code, or to lead you step-by-step through any part of the assignment. Any individual who shares code with you in violation of these rules is also themselves in violation of the Honor Code.
  • Always cite your sources. This might be code you might find on the Internet which is unrelated to the project requirements, so it’s allowed per the constraints above. This also includes assistance that you receive from a labbie or TA, where they perhaps gave you some critical 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 TA’s office hours who then gave you a critical insight; you then both independently implemented it. If you both have a code comment with the name of the TA and the date you were there, and if you satisfied everything in the previous bullet, then you’re fine. If we otherwise discover you having an identical solution and you didn’t give credit, you are in violation of the Honor Code.
  • When a labbie or TA has office hours, and there’s a big crowd, they will take care to protect the privacy of your work in progress. They won’t allow others to see it. This also means that you should take care not to look over the shoulder of your fellow students while they’re asking for help with their code.

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 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. Give hints. You want to make sure your peers understand the problem, rather than just getting it working without understanding why.

(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 be treated as a sign of potential plagiarism.

Public posting. 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 will 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 for example, it’s your responsibility to schedule your interviews around your school work.

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. We will not take your word for it. Yes, we know that Rice Student Health Services as a rule doesn’t write any such notes. Our requirement is unfortunately necessary in response to prior abuses.

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.

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 club meetings, and you should prioritize them appropriately.

The cone of silence. If we do approve your late assignment submission or you taking an exam at an unusual 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.