Course Information

• Time and Location
• About this Course
• Staff
• Policies
• Grading
• Google Groups
• Academic Integrity

 

Time and Location

Lectures (required)

Recitation Sections

The number of students in each section is taken from facultycenter (studentcenter) on 2 September. If more than one course exists at the same time, please change sections to even ut the numbers.

 

 

About this Course

CS 2110 (cross-listed as ENGRD 2100) is an intermediate-level programming course and an introduction to computer science. Topics include program design and development, debugging and testing, object-oriented programming, proofs of correctness, complexity analysis, recursion, commonly used data structures, and abstract data types. Java is the principal programming language.  The course syllabus can easily be extracted by looking at the link to lectures. Here are the expected course outcomes:

Outcome 1: Be fluent in the use of recursion and object-oriented programming concepts (e.g. classes, objects, inheritance, and interfaces).

Outcome 2: Be able to design and implement nontrivial Java programs (roughly 1000 lines of code), starting from an English language specification.

Outcome 3: Be able to design graphical user interfaces (GUIs) in Java.

Outcome 4: Understand asymptotic complexity of algorithms and be able to analyze programs to determine their running times.

Outcome 5: Understand basic data structures.

The official prerequisites are CS 1110 or CS 1112 or equivalent background. This means that you must have a working knowledge of basic programming in some programming language, but not necessarily to Java. About 60% of students have not seen Java prior to taking this course, so, if your lack of knowledge of Java makes you nervous, you are in the majority!

A complete listing of topics, lecture-by-lecture, appears on the lecture notes page.

The ppt slides that are posted for later lectures are from the Spring 2013 version. Each will be updated a few days before that lecture.

Each lecture will be best appreciated if you download the ppt slides the day before the lecture and spend a few minutes going over them; then, during the lecture, have them available to look at, either in paper form or on your laptop or tablet.

In CS 2110, you will learn about:

• the Java programming language
• concepts in modern programming languages, including classes, objects, inheritance, recursion, and generic programming;
• data structures, such as lists, stacks, queues, trees, hash tables, graphs, and collections;
• how to produce correct, well-structured, readable, and maintainable programs.
• the ideas underlying "types" as used in modern programming languages.
• a bit about Java's flaws and limitations. No language is perfect. You'll also learn about the powerful features and the issues associated with Eclipse, the interactive development environment (IDE) we use.

Note: CS offers a 1-credit enrichment course CS 2111. We encourage anyone who is unusually nervous about Java or object orientation take it. In the single weekly hour, you will see us talk about the material from different perspectives, reviews of material, more elaboration of assignments, and preparation for the tests. You will have a chance to ask more questions. The course is S/U and requires no homework.

 

Instructor

	NAME & INFO	OFFICE HOURS
	Ken Birman ken@cs.cornell.edu 255-9199 4119B Upson	Ken's office hours are Tues, Wed, and Thurs 1:15-2:15 or by appointment (email Amy Finch: Amy@cs.cornell.edu). In addition, he tries to be available after class on Tuesday and Thursday (11:15am to noon). Sometimes, Cornell has visitors or there are meetings that he has to attend. If these would conflict with his scheduled office hours, he post a notice on Piazza and cancels his normal hours.
	David Gries gries@cs.cornell.edu 255-2998 5158 Upson	David's office hours are Wed 10:00–111:30. 1:00-2:00. or by appointment (email Gries). If in his office, he generally can speak to anyone who drops in. He is generally not in on Mon and Fri. If a conflict arises, he posts a notice on Piazza and cancels his normal hours.

It never hurts to double check before walking to Upson. You can always email or call Birman or Gries to confirm they are in the office.

Teaching Assistants

The TAs mainly teach recitation sections and assist with homework and exams. All TAs hold office hours, and we encourage you to attend them if you have difficulties. Here is the link to the table of office hours.

During the study period and finals, office hours are by appointment only

Course Administrator (CA)

The CA provides clerical and logistical support for the course. Please notify the CA of any errors or discrepancies in the website.

	NAME & INFO
	Amy Finch (amy@cs.cornell.edu) [NOTE: please contact the TAs and NOT Amy for CMS add/drop issues] 255-5331 4120 Upson

Consultants

CS2110 has 30-40 consultants: undergraduates who have excelled in their coursework and are employed as tutors and graders. Consultants hold office hours in Upson 360. They are always happy to help with Java and Eclipse issues. See the consultant schedule.

Policies

Makeup Exams (sorry, not possible)

We don't offer makeup exams in cs2110. There are too many reasons for this to list them, but the main reason is that we work hard to create these exams and creating two of them isn't practical. Also, no two exams are of identical difficulty.

Instead, if you have two exams the same evening, we let you start our cs2110 prelim early so that you finish in time to get to your other exam. Have your other instructor agree to let you start a few minutes late. This way you will have a half hour to unwind between finishing ours and starting the other one. If someone needs to take the early version of our exam for some other reason, we're usually flexible about it. To ensure that academic integrity is respected, we won't let people leave our early exam session until people are in the room and seated for the second session.

If you miss an exam, and we gave you permission to do so, we modify the grading formula to compute your grade with just the two other exams. If you miss an exam and we didn't excuse you, that can be a bit sticky: we would average in a zero for the missing score. So please put dates and times of the exams into your calendar reminder system! Ask us for permission, don't just skip exams and assume you can patch things up later.

Special Situations

We follow Cornell's university-level policy when issues that fall under that policy arise. This covers a wide range of special situations including disabilities, health or family crises, etc.

As a practical matter, this sometimes means we need to excuse you from a particular exam, give you a bit of extra time on an exam or an assignment, or work out a way for you to take the exam remotely.

In any semester we have a few students who need to schedule job interviews, attend professional conferences, or participate in off-campus sports events. We solve this by by having someone at the company, or perhaps the coach or a professor travelling with you or someone from the hotel or conference staff, agree to receive the exam, administer it at roughly the same time that everyone else takes the exam, and then send it back to us. That is, rather than have you miss an exam, if feasible we prefer for you to take it while interviewing at Microsoft or Google or wherever you happen to find yourself. This happens all the time. It won't harm your interview to explain the situation to the company and ask them for a little help on this. If you do the exam in your hotel, the company won't even need to know you took an exam that day.

You need to talk to us about this in advance and should try and it helps if you've already identified the person who can administer the exam. They won't need to watch you minute by minute, but will need to have some way to see that you aren't using your computer, phone, notes or textbook. For example, you might take the exam in the hotel "business center", which is usually somewhere near the front desk and gives them a chance to keep one eye on you. We really do try to have the exam occur during the same period that students will be taking it in Ithaca, so factor time zones in when you work out a proposed plan. If you are out of town due to a family emergency, we'll consider having a family member receive the exam and send it back.

Grading

All assignments and exams receive scores out of 100 points. Your grader's comments will be posted on CMS. The grading guide will be posted as well, so you can see why points were deducted.

You may receive bonus points for exceptionally nice work on assignments, and some assignments have extra credit options. Bonus points do not count in the computation of your score on that assignment, but are accumulated separately in a single bonus score for the semester.

Submission of assignments and the lateness penalty

An assignment may be submitted more than once on the CMS. All submissions are kept, but we grade only the latest one. Try to submit well before the 11:59PM deadline. The closer to that time, the more students are submitting, the higher he chance that the CMS will be overloaded and break down or not handle your submission properly. That is your problem. We do program a grace period of an hour or two into the submission time.

The lateness penalty for assignments is 3 points the first day, 4 the second, and 5 each day thereafter. Eventually we lock down CMS, and you can't hand the assignment in at all. Normally, this occurs after 5 days, but we may make an exception if extra time is needed for some reason. We do program a very short grace period into CMS.

Weights

Note: This whole section was revised by Ken 12/11/2013, but the process is the same as it has been for many years, including the way we compute scores and assign letter grades.

Grading is a bit complicated for CS2110, for many reasons.  First, this is a large course and a gateway into the CS major.  We think of grades as sending a message (if you get a grade in the B or A range, that's not just a statement about CS2110, but also our way of encouraging you to do more with CS: consider taking more classes, or even majoring in CS, and using computational tools and thinking in your work outside of CS too).  A C is a fairly common grade in CS2110, with 30% or more students finishing in the C range (we also give D and F grades but we hate to do that and it is rare).  We don't think of a C as a bad grade, and for us it is a way to alert you that while you passed the course, you aren't really using computing as proficiently as you would need to in order to well in follow-on courses.  This doesn't mean you shouldn't take more CS courses, but it might mean you need to plan to spend more time on them, get more practice writing code, etc.

A second complication is that the course management system (CMS) we use can't actually precompute the formula we'll use to come up with letter grades.  As a result, while the CMS reports a score continuously, it won't be anywhere near as good as predictor as letter grades as we think it should be.  Yes, this should be fixed, but for many reasons it is very hard to fix this particular issue.  We recommend that you ignore the CMS score entirely.  If you do look at the CMS score, be aware that it could be too high -- could predict a higher outcome than you will really achieve.  The reasons will become clear below, but in a nutshell, CMS just computes a kind of rolling average.  Our scoring methodology is a bit more sophisticated.

The effect of this is that until the very end of the semester, CMS tends to overemphasize assignment scores.  Yet in the way we handle assignments, nearly everyone can reach the 90% range on their assignment grades.  As a result, it can look (on CMS) as if the whole class is likely to earn an A.  In reality the prelim and final scores count for a great deal and in fact are probably the most important contribution to what really determines letter grades.  Doing really well without a lot of help on assignments does predict great prelim scores and a great grade.  But keep in mind that for many students, there are a lot of forms of help available for assignments: a partner, TA and consultant help, the instructors (office hours, etc).  Thus you can always send an SOS on a homework assignment, and you can usually get the sort of assistance that will help you get that assignment right.  But on an exam, we feel that we're testing what you really learned.  Thus the exam grades are a big factor in the way we end up computing letter grades.  CMS, on the other hand, doesn't really "understand" that and worse, has a very limited way of computing scores.  So please don't be fooled if CMS reports a bright and rosy score that seems to ignore weak prelim grades.

We don't grade according to a rigid formula or a rigid curve, but in fact we do aim for a rough breakdown in CS 2110: about 30% A grades, 40% B grades and the rest C's and D's, as noted above.  Thus there is a form of curve, and what drives it is performance of the individual relative to the mean.  On each exam you should look at how you did relative to the mean.  Don't trust the absolute scores in a literal way: sometimes one exam is a bit too easy or a bit too hard, so a score of 83 might not be a B, and a score of 73 might not be a C-.  Ask whether you are doing better than the mean, average, or below.  This will give you at least a very basic feeling for whether you are in the A, B or C range.  Even if CMS seems confused, that basic feeling is likely to be on target.  A person getting grades above the means on our exams is doing very well.  A person consistently below the means could be heading for a C.

The way we compute letter grades starts by computing a final numerical score.  We do this by calculating a weighted combination of your scores for all required course work.  Some elements of this calculation are not available to you hence it is in practice impossible for you to carry this calculation out on your own, and we generally do not release the details to students (of course they would be available to the department chair and others who oversee our methodology, but those people can't release details either, due to privacy laws that apply to us here at Cornell). 

Here's how we compute the score, but there are some complications this won't capture. First, if we don't actually do 4 quizzes, we weight the ones we did do accordingly to get the right number of points.  Left over weight from the quiz shifts to exams, and in fact we often shift the weighting around beyond this; it is not uncommon for exams to carry a bit more weight than in the rubric below.   Second, we drop the low assignment score, but only if you turned in all five assignments. Exceptions are made for people who joined the course too late to turn in A1 and got our permission to not do that one. An unexcused missing assignment is averaged in as a zero.

ASSIGNMENTS (~40-45%)					QUIZZES (~0-4%)	EXAMS (~50-60%)			EVAL (~1%)
A1	A2	A3	A4	A5	Q	P1	P2	F	E
6-10	6-10	6-10	6-10	6-10	0-4	10-15	10-15	20-25	0-1

We give ranges above but keep in mind that CMS has some rigid number built in for each graded assignment or exam -- it forces the instructors to specify a weight, and then it uses the weighted sum to compute the score it shows you.  As a result, we give a CMS a weight -- we have to -- that might not be the weight actually used when we finally come up with our grading rubric.  This is one reason that the CMS score reported day by day during the semester may be incorrect.  Don't trust it!

"EVAL" is the University course evaluation. We get a list of people who fill it out, but the university keeps your responses anonymous. It is quite likely that the relative weights will be changed as the course progresses, due to changes in assignments, more or less quizzes, etc.  Notice that the effect of this is that assignments carry about 45% (but perhaps less) weight in our score, and exams 55% (but perhaps a bit more, and perhaps with some of this coming from the evaluation and quizzes).  We also sometimes normalize the mean on an exam, for example if it was a bit easier than historical exams or a bit harder.  We sometimes know we are offering an unusually easy or an unusually hard exam, and we sometimes simply learn this when we grade it.  Thus exams can have a normalizing factor added or subtracted from the score before we compute the weighted score.  These factors would be in the range of 0 to a maximum of perhaps 5 points.

Bonus and extra credit points are added into the assignment score or exam score, but we cap those scores at 100 before computing the weighted score. For example, suppose you got 85, 79, 92, 97, and 100 on A1..A5, and along the way you earned 11 extra credit/bonus points. We drop the 79, sum up the 85 through 100, add in the 11, and then multiply by 45/400. We cap this at 45. That gives us the assignment part of your "score". Notice that the extra credit/bonus points for A2 (if there were any) counted even if we dropped A2 because it was your lowest assignment score.  The same approach is used to include extra credit on an exam.  And also notice that the 45% number assumed that the assignments were worth 45%.  We don't really finalize that decision until we do the letter grading for the course, and that decision reflects a few factors.  Again, this makes it hard to know what letter grade you will have other than in crude terms.  And as you can see, the best crude estimator is simply to look at your performance on exams relative to the mean on those exams.  Anything else involves guessing about decisions we may not have reached yet, and that we won't be able to divulge in detail in any case.

Grade Computation

We do not grade statistically on a standard, fixed, rigid curve, e.g. with people getting within a standard deviation of the mean getting a certain grade. If all students do A work, all students will receive A. But as explained earlier, we intend that A work send a certain message, as does B, and C.

Determining those letter grades is one of the hard tasks that we, as instructors, are charged with doing.  We need to decide, at the end of each semester, what A work is, what B work is, etc. And that does have to depend to some extent on how the class as a whole performs. Generally, the median grade for this course has been about a B.  Thus the score doesn't map directly to a letter grade.  Rather, once we have the scored ranking for the class, we ask ourselves what score value should correspond to the A range?  What range should be the B's?  This process is one we spend a lot of time on, and we compare against statistics from CS2110 over the years to see whether we are grading fairly relative to past offerings of the course.  Our goal is to be fair, uniform, and to send a message that makes sense (again, see above). 

Cornell CS grading thus will often depart from what you may have experienced in high school, where a score of 80-90 probably guaranteed an A, and where if you got lucky and a professor gave an unusually easy exam, it led to an easy A (and the converse probably happened too: if you were unlucky and a professor gave an impossibly hard exam, you probably got locked into a situation where the resulting low score was treated as a C even if you were the best in the class on that exam).  In CS 2110, our goal is to guarantee an A for A work, but to use the fairest and most historically accurate scheme we can to decide what scoring range corresponds to A work.  We do this at every level of the whole grading range.

We determine letter grades for the course using your final numerical score, but we also take into account knowledge of each individual —performance on extra credit, did someone perform poorly on an exam because of illness, did sudden personal issues affect performance, etc.  

Fall 2013: Optional Final

In the fall of 2013 we experimented with an optional final.  We have not done this in cs2110 in the past and are not sure we'll do it again in the future.  It worked this way: After the last day of classes when the assignments were all graded, we computed a tentative letter grade based on the approach described above, but lacking the final (so the prelims had a very big weight).  We released this via CMS and if a student was satisfied, they could "accept" the letter grade.  We promised that such a grade wouldn't go down (we reserved the possibility that it could go up, in a few cases, so that if something seemed to be unfair later when we had the final grades in the mix, we could address those issues).

A bit more than half the class accepted the tentative grades.

We then ran our final, graded it, and for the group that opted for it, recomputed the score with the final now in the mix.  We looked at how this shifted people around.    We assigned new letter grades for these students and then revisited the tentative ones, as just explained.  Although all this made grading a bit laborious, because the numbers of students were large, and because the final is a rigorous and cummulative test of everything covered in the course, we think the outcome was very fair.  It gave us a very good insight into how well each student had mastered the ideas and material covered in the course.

Why don't assignments count more heavily?

With us dropping the low assignment score, some students find that they work hard on homework throughout the semester, and yet nearly everyone ends up with a very high homework score.  Then they might still end up with a fairly low letter grade.  It can be frustrating to work hard and yet get a low letter grade.  (Such a person probably would have had trouble on tests, but feel that they do better on homework with unlimited time, and of course many sources of help when they get stuck).   The key insight is that first, with our help, we want you to get a good feeling for how to succeed in building tricky pieces of software.  So yes, this help does lead to high scores, but on the other hand, without that help not all students could master the material at a high level of proficiency.

The second insight is that proficiency on the assignments, especially the ability to work at this level individually without a lot of help, prepares you extremely well for the exams, which have a lot of coding questions and puzzles that relate to computational ways of thinking, object oriented computing and data structures.  So the hard work done on homework will pay off on higher exam grades.  A student who never really masters the material may get enough help to do well on the homeworks, but will probably not do as well on the exams.  While this can feel harsh, keep in mind that in future CS courses you won't have quite as much help available -- CS 2110 is unusual in having such a large staff available 24x7.  So to continue in CS it is really important to reach a point of being able to work independently.  Thus your exam scores do shape the letter grades more than the homework does, but the homework still plays a vital role.

Piazza

Piazza hosts a public forum that we use for discussing questions about the assignments. The course staff monitors this group regularly, so this is a great way of getting help and interacting with the course staff. An extra advantage of using the group is that everyone else can benefit from your question as well. Anyone can visit the group and read previous questions here .

If you know the answer to a question, feel free to post a reply yourself, but please avoid giving away any hints on the homework or posting any part of a solution. This will be considered a violation of Academic Integrity. Generally, rough algorithms or non-solution-specific code fragments are OK if you need them to illustrate a point.

 

Academic Integrity

The utmost level of academic integrity is expected of all students. Please read the following webages carefully. The second one is a great resource for both students and faculty, looking at Academic Integrity from all viewpoints and answering many questions about procedures.

• Cornell University Code of Academic Integrity
• www.theuniversityfaculty.cornell.edu/AcadInteg/
• Computer Science Department Code of Academic Integrity