UCR CS 12: Introduction to
Computer Science II
Fall Quarter 2003: September 22, 2003 - December 13, 2003
Lecture Schedule
Lab Schedule
Current Grades
Exam Schedule
Coding Style
Guide
Electronic Turn-in
Course Email List
Anonymously Report
Suspected Cheating
Anonymously Provide Comments/Suggestions
FAQ page
Previous CS12 Offerings
In CS 12, you'll learn
to solve larger programming problems and will also touch on some
of the deeper concepts underlying Computer Science. Hopefully
you'll also have fun too!
Catalog description: CS
12. Introduction to Computer Science for Science, Mathematics,
and Engineering II. (4) Lecture, three hours; laboratory, three
hours. Prerequisite(s): CS 10 with a grade of "C-" or better;
familiarity with C or C++ language. Structured and
object-oriented programming in C++, emphasizing good programming
principles and development of substantial programs. Topics
include recursion, pointers, linked lists, abstract data types,
and libraries. Also covers software engineering principles.
Note: students
receiving less than a C- in the CS 10 prerequisite will be
dropped automatically a few weeks into the quarter.
Instructor:
Wagner
Truppel (wagner@cs.ucr.edu,
Surge 340)
Office hours:
by appointment only, requested by email, and
not guaranteed unless you receive a confirmation reply.
Teaching Assistants:
David Sheldon (dsheldon@cs.ucr.edu)
Office hours:
Tue 3:30pm - 4:30pm
Thomas Repantis (trep@cs.ucr.edu)
Office hours:
Thu 10am - 11am
Nan Xiao (nxiao@cs.ucr.edu)
Office hours:
Wed 10am - 11am
Guobiao Mei (gmei@cs.ucr.edu)
Office hours:
Mon 1pm - 2pm
TA office hours held in
Surge 282.
Lectures:
Section 001: Tue & Thu 11:10pm-12:30pm
Sproul 1340
Section 002: Tue & Thu 12:40pm-2:00pm
Olmsted 1212
Labs:
Section 021: Tue 8:10am-11:00am
Surge 171
Section 023: Wed 2:10pm-5:00pm
Surge 283
Section 026: Mon 6:10pm-9:00pm
Surge 171
Section 028: Fri 6:10pm-9:00pm
Surge 171
Lab attendance is required. Attendance will be taken at
the beginning and end of every lab section, and points awarded
accordingly. During lab sections, you are expected to be working
on material related to this course.
Textbook:
Problem Solving With C++, W.
Savitch, 4th ed., 2003 Addison-Wesley.
Please consult the errata pages for the book because
there are always errors and typos in every book. In addition,
you might want to download the book's PowerPoint slides and code
samples. The errata, slides, and code samples are all available
for download from the book's web page.
For optional books, visit the Additional Resources section
below.
Extra (Optional) Readings:
In addition to the required readings, I've made available
photocopies of certain book chapters which I believe have clear
presentations of some of the material to be covered in the
course. This is not mandatory reading. This extra
material is accessible from the UCR Printing and Reprographics
Office on campus, next to the UCR Bookstore's entrance. Just
ask for the CS 12 Readings.
Course Email List:
CS 12
mailing List (send
mail now or access the
archive): Be sure to sign up to receive important
announcements and other information. You must use your CS or EE
account, or else some other UCR account, so be sure to learn how
to read those accounts or at least automatically forward
messages to your personal email address (just create in your
home directory a file named ".forward" containing your personal
email address).
Assessment Schedule:
Home Programming Assignments: turned in electronically by
8 pm on Sundays, unless otherwise noted by the instructor.
Quizzes: almost every Tuesday, at the beginning of the
lecture. There may also be pop quizzes at any time.
Midterm: Thursday, October 30, during that day's lecture.
Final: (to be held in the same classroom where the
lectures take place)
Section 001: Thursday, December 11, 11:30am - 2:30pm
Section 002: Tuesday, December 9, 3:00pm - 6:00pm
Course Grading:
Letter grades will be assigned roughly according to the
standard 90/80/70/60 scale out of 100 percentage points overall,
with a 90 and above corresponding to an A, 80 and above to a B,
70 and above to a C, 60 and above to a D, and less than 60 to an
F. +/- grades will be given out as appropriate. A+'s will be
given to students in the high 90's who also have turned in all
required material and many of the challenge in-lab exercises.
The course is divided into two grading components, combined as a
weighted sum to total 100 points:
-
65% - Lecture component:
-
5% homework assignments - There will be
weekly homework assignments designed to help you practice the
concepts learned in the lectures. These assignments may or may
not be graded, or may be graded only partially. Questions from
these assignments will be used in the quizzes and exams.
Solutions will be provided online.
-
10% quizzes - Designed primarily to cover
material learned in lecture and lab during the previous week,
regular quizzes will be held on most Tuesdays at the beginning
of lecture. There may also be a number of "reading quizzes" held
at the instructors discretion covering the assigned reading
material, as well as "pop quizzes." Students must therefore
bring paper and a writing implement to every lecture.
-
20% midterm - There will be a midterm held
on Thursday, October 30. It will cover all the material
presented in the course up to that date, as well as basic C++
concepts learned in CS 10.
-
30% final - The final exam will be
cumulative, covering all of the material presented in the
course both in lab and lecture.
-
35% - Lab component:
-
10% scheduled lab section attendance,
participation, and lab exercises.
-
17% at-home programming assignments.
-
8% in-lab practical exams - There will be 2
in-lab practical exams held during the quarter. Lab practicals
will be short (30 minute), closed book, no-assistance
programming assignments to ensure that you are absorbing the
programming material. Notice of the exam dates will be given in
lecture, during scheduled labs, and on the mailing list, at
least 3 days in advance.
To ensure minimum competency in successive courses requiring
a C- or better in this course, a C- minimum in both
components is necessary to achieve a C- minimum for the final
course grade, regardless of the components' weighted sum;
otherwise, the final course grade will be no greater than a
D+. For example, a B in the lab component and a D in the
lecture component might yield a weighted sum of a C, but would
instead result in a final course grade of D+. A C- in either
component corresponds to roughly 70% of the total points for
that component.
Approximate Time Requirements:
This is a four-unit CS course. As such, you should expect to
spend the following approximate amount of time (double these
estimates for summer session offerings):
3 hours/week attending the lectures.
3 hours/week attending the lab sessions.
6 to 10 hours/week doing individual study (readings,
homeworks, programming, lab preparation, etc).
Please do not underestimate the time you will need to spend
on this course. These are real time amounts spent by average
successful past students. Computer Science and Engineering are
challenging disciplines requiring extensive time to master.
Subject to change as the quarter progresses.
Please note that even though almost all the chapters in the
textbook will be covered in the lectures, only a few of
those will be covered with the level of detail presented in the
book. Therefore, it's crucial that you read the book as
we go along.
Do not put off reading the assignments or you will risk falling
behind. Reading ahead is one of the most effective ways of doing
better in class -- you'll be amazed how much more comprehensible
and useful the lectures will be.
-
Week 1: Course overview. Review of some basic ideas from
Computer Science. Structured Programming concepts: Top-Down and
Bottom-Up approaches. Overview of OOP.
Readings: handout 1 (pdf) and chapters 1, 2,
3, 4.
Week 1 slides (pdf /
pps).
Homework 1 (solutions) due Tuesday, October
7.
Quiz 1 solutions.
-
Week 2: Review of CS 10. Introduction to Elementary Data
Structures: Arrays.
Readings: sections 10.1, 10.2, and 10.3.
Week 2 slides (pdf /
pps).
Quiz 2 solutions.
-
Week 3: Introduction to Elementary Data Structures:
Queues and Stacks. Functions and Activation Frames. The
Divide-and-Conquer approach to solving programming problems.
Recursion I.
Readings: handout 2 (pdf) and chapter 13.
Week 3 slides (pdf /
pps).
Homework 2 (solutions) due 8:00 pm, Sunday, October
19.
Quiz 3 solutions.
-
Week 4: Recursion II. C++ Structures. Pointers and
Dynamic Arrays. C++ Static and Dynamic Memory Allocation.
Readings: chapter 13, sections 6.1, 12.1, 12.2.
Demo: The Towers of Hanoi (html / jar).
Week 4 slides (pdf /
pps).
Homework 3 (solutions).
Quiz 4 solutions.
-
Week 5: Introduction to Object-Oriented Programming. C++
Classes. Brief introduction to UML. C++ Constructors.
Midterm.
Readings: sections 6.2, 6.3, 10.4, 12.3.
Week 5 slides (pdf /
pps).
Homework 4 (solutions).
Midterm solutions.
-
Week 6: Inheritance and Polymorphism I.
Readings: chapter 16.
Extra readings: CS 12 Readings, available from the UCR Printing and Reprographics
Office.
Week 6 slides (pdf /
pps).
Homework 5 (solutions).
Quiz 5 solutions.
-
Week 7: Inheritance and Polymorphism II.
Readings: chapter 16.
Extra readings: CS 12 Readings, available from the UCR Printing and Reprographics
Office.
Week 7 slides (pdf /
pps).
Homework 6 (solutions).
Quiz 6 solutions.
-
Week 8: C++ Operator Overloading, Friends, and
References. Classes and Dynamic Memory Allocation, Destructors.
Readings: chapter 8, sections 10.4 and 12.3.
Week 8 slides (pdf /
pps).
Homework 7 (solutions).
Quiz 7 solutions.
-
Week 9: Abstract Data Types. C++ Templates. Elementary
Data Structures: Linked Lists I.
Readings: chapters 14 and 15.
Week 9 slides (pdf /
pps).
Homework 8 (solutions).
Quiz 8 solutions.
-
Week 10: Elementary Data Structures: Linked Lists II.
Readings: chapter 15.
Week 10 slides (pdf
/ pps
).
Homework 9 (solutions).
Quiz 9 solutions.
Subject to change as the quarter progresses.
-
Material covered: You'll be responsible for
learning material covered in lecture, in the textbook, and in
lab. Lecture does not cover all required material alone.
-
Academic dishonesty: cheating is strongly
punished (typically with an F in the course). You can report
cheating anonymously at:
https://www.cs.ucr.edu/cheating/. Assignment submissions
must represent your own original work. Copying from any sources
(web, other books, past or current students, etc.) is strictly
prohibited -- learning to program requires you to learn to solve
programming problems by yourself; using existing code and other
resources becomes important later on in your studies.
While discussing assignments is encouraged, team coding
(even of pseudo-code) or letting others see your code are
specifically not allowed. Be aware that programs are
automatically compared to the current and prior quarter's
programs for plagiarism, using a sophisticated code-comparison
tool that ignores insignificant differences (like whitespace and
variable names). If you're smart enough to fool the instructors,
TAs, and code-comparison tools, you're more than smart enough to
do the programs on your own!
A couple more notes. Be aware that a subset of exams may
be photocopied, for comparison with exams submitted for
regrades. Also, be aware that lying to an instructor in order to
be able to make up a missed exam or in other ways to obtain a
better grade can be treated as academic dishonesty. During
exams, cell phones must be stored away in a place not visible
(e.g., inside a backpack).
-
Final Exams are scheduled by the University, not
by the instructor, and are correlated to the course sections.
What that means is that you must take the final exam scheduled
for the section you are enrolled in.
-
Regrade policy: regrade requests must be
submitted in writing and within one week of the
distribution of the graded material. The entire exam/assignment
may be regraded, not just the problem in question, so the grade
may go up or down. Thus, think your regrade requests through
carefully. Grade-database errors should also be pointed out
within one week of posting.
-
Final grades: Per university policy, changes to
your final grade will be made only in the event of a
clerical error. Asking your instructor how far you were from a
cutoff and what extra work you can do to improve the grade is
not appropriate.
-
Switching/adding/dropping lab and lecture
sections: all add, drop, and section changes of all
lower division Computer Science courses, after the period when
students can do so electronically is over, are done through the
College of Engineering's Student Affairs office. Neither
the instructors nor the CS department itself can sign any
add/drop forms, nor can they arrange for section changes. Please
go to Student Affairs, Bourns Hall A159, for any such changes.
-
Communicating with the instructors and TAs: when
sending electronic mail to the instructors or TAs, please
include your full name, course & section details,
student ID number, and UCR email address, so that
we may properly identify you (remember, many students have
similar names, and instructors may be teaching several courses).
Also, please try to be polite and use reasonable grammar and
formatting.
-
Cell phones: During lectures and lab sessions,
please turn off your cell phone.
-
Homework and lab reports: All turned-in
assignments will be turned in electronically. Each file
should begin with our report template header. Source code must
comply with professionally accepted coding
standards. Also, you must include a section
explaining the design, structure, etc of your program and
how it works. Comments in source code are important, but they
are not a replacement for an explanatory section. Please
remember that successfully writing a computer program that
compiles and runs correctly is not something anyone can do in
just a few minutes, even when it looks easy. Debugging typically
takes three times longer than figuring out how to write
your program. So don't leave your programming assignments to the
last minute!
-
Reading: Read the current book sections
before coming to lecture, and attend all lectures in
their entirety. To encourage these important college study
habits, we may give a few simple pop quizzes during the quarter,
at any time during lecture.
-
Students are required to stay the full three hours of
lab session every week. You'll have in-lab exercises,
discussions, and practical exams. Work ahead or on extra
course-related material if you finish early.
-
During lab discussion time, students should not use the
computers. Ideally, students would move their chairs to the
whiteboard area.
-
Prepare for lab before arriving.
-
To reduce disruptions and provide for the best
educational environment, all persons in lab during scheduled lab
time should be formally registered in that section. In general,
no swapping sections and no unregistered people in the lab are
allowed, even if there are extra computers.
© 2003 UC
Riverside Department of
Computer Science & Engineering. All rights
reserved.