ECS 110 - Course Information
You are responsible for everything on this handout. Read it.
Section A - Phil Rogaway - TR 10:30a-11:50a - 55 Roessler
Section B - John Matthews - TR 12:10a-1:30p - 55 Roessler
Discussion sections begin next week. For the first week, the Wednesday
discussion sections will be held in the normal locations but will simply
be office hours for the TAs. If you have questions on the first assignment,
you can drop by then or any of the regular office hours. Normally,
you should go to one discussion section each week. The same material will
be covered Monday and Wednesday. Early discussion sections will give
you help in C++, while later discussion sections will deal more with lecture
- M 3:10p-4:00p - 148 PhyGeo
- M 5:10p-6:00p - Temp #2
- W 2:10p-3:00p - 148 PhyGeo
- W 5:10p-6:00p - Temp #2
Course Web page
We will maintain all sorts of information on the course
Web page: http://wwwcsif.cs.ucdavis.edu/~cs110.
Visit this page regularly to see what's new.
If you miss a handout, get it from the Web.
Some information (like test cases or
fragments of code you may use) will be available only on the Web.
There will be one midterm held on Tuesday of the sixth week (May 6). It will
be held during the normal lecture period.
The final for Section A (Rogaway) is Wednesday, June 11, 4:00-6:00pm, in 55 Roessler.
The final for Section B (Matthews) is Thursday, June 12, 8:00-10:00am, in 55 Roessler.
Both the midterm and the final will be closed book, closed notes.
ECS 40 or equivalent. This is a serious requirement; you are assumed to have mastered the
concepts and developed the maturity appropriate to having completed that course.
Data Structures and Algorithm Analysis
by Mark Allen Weiss
Moving From C to C++
by Greg Perry
The C++ Programming Language (second edition)
by Bjarne Stroustrup
Your programs will be written in C++. You will not be taught much
C++. To learn it you will need to buy some C++ text (such as the
recommended books) and study it on your own. A useful on-line
source is available
This is a course in data structures. This is not a course
in C++ or Object Oriented Design. We will cover standard material
on data structures, like stacks, binary trees, graphs, heaps, etc.. At
the end of this course you should be able to choose the right data
structures for a programming task; analyze the behavior of basic
algorithms which use data structures; and implement in a clean manner algorithms
which make use of nontrivial data structures.
You will be doing five programming assignments, all in C++. The first
assignment (0) is a trivial one designed simply to allow you to become
familiar with the development environment. The other assignments
are designed to help you bridge the "theory" and the "practice."
They also aim to give you experience with increasingly large or interesting
programming problems. We intend to make the programs
challenging (except Program 0). Start early.
All students registered in this class should have accounts already setup.
Use the instructional workstations in the basement of Engineering II.
If there is a problem, see the student programmers first (they are in the
basement of Engineering II). They keep long hours and are very helpful.
The student programmers also respond to mail: the address is support@cs.
You are encouraged to use your own machines for working on the assignments.
However, all assignments will be graded using the DEC workstations and the
g++ compiler. Therefore,
you must make sure that your program compiles and executes correctly in
that environment and submit you programs electronically from there.
Read ucd.class.ecs110 regularly; you are responsible for everything posted
there. There is also a ucd.class.ecs110.d discussion newsgroup; read
this if you want to. This newsgroup is for you to talk among yourselves
and answer one another's questions.
Many students are shocked by the "you're-on-your-own attitude"
we take towards your learning a new programming language. Be assured that
it is not that hard to pick up a new programming language (even one as
complicated as C++) just by reading a book. Mostly, you should learn C++
from your reading. But we suggest that you experiment a bit on the computer
as you do the readings, making up some toy programming tasks. You
will get some help learning C++ from the early discussion sections, but
do not count on the discussion sections to teach you all you need to know.
We strongly advise you to get started learning C++ immediately.
There will be five programming assignments, one midterm, a final, and a C++ quiz.
Assignment 0 must be turned in and correct.
The other four assignments will count for
about 40% of your grade (10% each); the midterm 20% of your grade, the
final about 37% of your grade; and the C++ quiz for about 3% of your grade.
For each assignment, approximately 60% of the grading will be based on
having a working program; the other 40% will be based on style and approach.
In order to pass the course, at least two of four main assignments (not
including assignment 0) must work. In order to receive a grade >
C, three of the four main assignments must work. The midterms and
final are closed book, closed notes.
Turning in the Assignments
Except for assignment 0, for which we want softcopy-only, you must turn
in hardcopy AND softcopy.
Softcopy is turned in
using the handin command.
Detailed information on how to use handin is available
Assignments must be turned in
before midnight (i.e., 11:59.59 of the indicated day).
A makefile must be provided.
The grader will do no more than type make to build your executable.
If make is absent or won't build the executable
you're going to be losing 60% of the assignment's points right off, so do make
sure it works.
Hardcopy is turned in at the appropriate box of
Engineering II, room 2131.
Hardcopy must include (in this order)
(1) your (carefully written) 1-2 page design document;
(2) your code; and
(3) a script showing your program running on your test cases.
Please highlight your function names and key classes
to facilitate grading.
By convention, hardcopy is due by 10:00 am of the first school
day following the scheduled due date.
(If the assignment is due Friday at midnight,
the grader will not be able to retrieve
hardcopy until the following Monday morning.)
Despite the fact that hardcopy is collected after
softcopy is due, the sensible thing is to do your design document
well before you have completed coding (some would say before you
even begin coding).
(The reason for having you turn in both hardcopy and softcopy:
the hardcopy is easier to grade for aspects of style,
and having you turn in hardcopy lets you draw pretty pictures
in your design document, which can be quite useful to communicate
data structure ideas.
The softcopy lets us verify that your program performs as advertised.)
You are allotted a total of 5 late days (calendar days) for all assignments.
Assignment 4 may not be turned in late. You can use these 5 late
days in any combination you desire, but we strongly suggest that you use
them wisely (if you use them at all).
If you use them all up on the first assignment, you
will not be able to turn in any other assignments late. There will
be no partial credit on a late assignment once you have used up all of
your late days.
Write your own code
You are encouraged to discuss program design with fellow students, but
all the code should be written on your own. Don't use a friend's
code. Don't modify someone else's code. Don't use class libraries which
you might dig up (except, of course, for standard libraries like iostream).
This might not be the way that programming works in the real world, but
it's the way things work in this class. Build your programs from scratch
(it's more fun that way, anyway).
When you discuss the ideas behind a program's solution with a friend, that
is fine. But please indicate on your writeup with whom you have exchanged
ideas. This has no effect on the grading of assignments.
We have experienced problems with people turning in substantially identical
programs. Contrary to students' expectations, it is rather easy to
spot such things.
Incidents of academic misconduct will be reported to the UC Davis Office
of Student Judicial Affairs. The penalties can be severe.
If you work with someone in the design stages, that is fine.
But you must credit your collaborator(s) in your writeup.
When you turn in a program you are certifying that
(1) you wrote the code yourself; (2) you did nothing to intentionally facilitate someone
else copying your program; (3) you have indicated all the people with whom
you had substantive exchange of ideas.
If you're asked to turn in output then you are further certifying that
(4) the turned-in program produced the turned-in output.
If you are having personal or academic difficulties which are tempting
you to engage in such misconduct, please come speak to your instructor instead.
We're not so bad!
For many of you, this will be your first taste of "real" programming.
Real programming is about finding good abstractions.
Being clever. Creative. Elegant.
Good programming is much more than hacking.
If you're used to taking the assignment, reading it, then typing in the
code, forget it, it's not going to work for these assignments.
If you find that you are spending lots of time in front of the machine and
not much time thinking or reading the book,
chances are that you're not taking the design aspect of programming seriously enough.
Step back and think. Understand the problem you are trying to solve.
Sit beneath a good tree. Work things out on paper. Consider alternatives.
Refine your ideas a few times.
Then type in a correctly working program!
This way not only takes less time and
leads to better results, but it's much more fun, too!