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

Course Syllabus

 

Introduction

Comp215’s purpose is to introduce you, the student, to a variety of useful techniques in the world of computer science. We assume you’ve had Comp140 and Comp182, 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 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. Projects will be performed 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’ll learn a little bit about building web applications. Those projects will still have weekly deadlines, even though any one project may be several weeks long.

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 Java7, there aren’t books like that for Java8. 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’ll be fine.

Lectures and Labs

Comp215 meets MWF 9:00-9:50am in Sewall 301. 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 three sections, each of which has a corresponding lab time. You must 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 Humanities 117:

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

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. Otherwise, if you do not attend any lab, you will not get that week’s lab point.

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. If you do not have a suitable laptop computer, please let us know ASAP and we’ll see what we can do. Also, do not have very many power outlets. Please make a habit of charging up in advance.

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), WF 10-11 (after class)
  • Budimlić, DH 3081 (third floor, near the Kennedy Conference Room), MW 1-2PM
  • 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 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.

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 will be one point. Exams will be graded out of 100 points. These will be weighted as follows:

  • Weekly programming projects: 50% (see details below)
  • Weekly labs: 20%
  • 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 afford a one week skip, but you should take care to save it for later in the semester if you really need it later.

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. For projects, include the code in question, the feedback you got from your grader, and 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.

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.

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 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 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, etc.) 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 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 text adventure game, where the goals of the assignment are for you to design the relevant data structures and game mechanics, we won’t have a problem with you using an external library that somehow lets you have cool fonts or images; 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. It’s common for Rice students 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, but 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, if you’ve figured out a clever way to do something and you want to proudly share it with your colleagues, here are some rules to guide you:

  • 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.
  • 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 fine to provide an explanation with examples of how to use a general-purpose API (e.g., we’ll see APIs for setting up a web server) or even how to use the reference code we provide you, but it’s not acceptable to provide examples that directly address requirements of the projects and labs.
  • Always cite your sources. Uncited copying is a violation of the Honor Code.
  • If you and your colleagues wish discuss topics directly related to the projects, put your computers and code printouts away. Doodling in pseudocode on a whiteboard is acceptable. If you can freehand a complete solution to one of our projects, then you’re still violating the cut-and-paste clause.

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. 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 signal of 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.
  • We will use plagiarism detection tools that compare your work to our reference code as well as your colleagues this year. 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 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 have travel requirements related to intercollegiate competitions or job interviews, we’ll do our best to accommodate your needs.

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.), you must 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 you to submit an assignment late or sit for 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 avoid 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.