UCR CS 12: Introduction to Computer Science II

2003 Summer Session II: July 28, 2003 - August 30, 2003

Overview

Basic information

• 65% - Lecture (Theory) Component: Represents your ability to reproduce simple information on demand, think abstractly, and answer questions about relevant course learning.
  
  
  • 15% quizzes and homework assignments - There will be 4 short (15-20 minute) quizzes during the session. Quizzes will primarily cover material learned in lecture and lab during the previous week. Regular quizzes will be held on Monday 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.
    
    Additionally, there will be lecture-related homework assignments given twice a week, assigned on Mondays (due on Wednesdays) and assigned on Thursdays (due on Mondays). These assignments may or may not be graded; either way, questions from them will be used in the quizzes and exams.
    
    
  • 20% midterm - There will be a midterm held on Thursday, August 14th. It will cover all the material presented in the course up to that date, as well as important material from previous CS courses (basic C++ concepts learned in CS 10).
    
    
  • 30% final - The final exam will be held on Friday, August 29. It will be a cumulative exam, covering all of the material presented in the course both in lab and lecture.
  
  
• 35% - Lab (Programming) Component: Represents your ability to implement in C++ the concepts presented in class or on the assignment webpages. This represents your ability to use the tools that you have been taught.
  
  
  • 8% lab practical exams - There will be 2 lab practical exams held during the quarter. Notice of the exam dates will be given in lecture and on the mailing list at least 3 days in advance. Anyone unable to attend the exam is required to schedule an alternate time with the instructor. Lab practicals will be a short (30 minute), closed book, no assistance programming assignment to ensure that you are absorbing the programming material.
    
    
  • 20% programming points - Over the course of the quarter you need to acquire 200 programming points to earn full credit in this portion of your grade. More information on the CS 12 programming point system can be found here.
    
    
  • 7% style - Part of your course grade will consist of the average of your style score on at-home assignments. That is, if you do only 2 home assignments, and receive 0 style points on the first and 10/10 on the second, you will be given 3.5% (7% * (0 + 10 points earned)/ 20 points possible). If you then turn in a 3rd home assignment and again receive full style points, your style score will then go up to 4.7% (7% * (0 + 10 + 10 points earned)/30 points possible).

Lecture schedule

• Week 1, first half: Introduction, course information, entrance quiz, review of some basic ideas behind computer programming: binary numbers, computer organization, programming languages, compilers, linkers, executables. Review of Procedural Programming, top-down and bottom-up approaches to solving programming problems. Review of some C++ concepts from CS 10: flow of control, functions, call by value, call by reference, function overloading.
  
  Read chapters 1, 2, 3 and 4 to review the material you learned in CS 10, then read the handout on computer organization (handout 1).


• Week 1, second half: Elementary Data Structures: Arrays and Stacks. C++ and statically defined arrays. Stacks, functions, and Activation Frames.
  
  Read sections 10.1, 10.2, and 10.3, then read the handout on stacks and activation frames (handout 2).


• Week 2, first half: The Divide-and-Conquer approach to solving programming problems. Recursion. The Towers of Hanoi puzzle and demo.
  
  Read chapter 13. Recursion confuses many beginners, so read that chapter very carefully.


• Week 2, second half: C++ Structures. C++ Pointers and Dynamic Arrays. C++ Static and Dynamic Memory Allocation.
  
  Read sections 6.1, 12.1, and 12.2. Pointers are also confusing at first, so read those sections very carefully.


• Week 3, first half: Introduction to Object-Oriented Programming. C++ Classes.
  
  Read sections 6.2 and 6.3.


• Week 3, second half: More C++ Classes. Brief introduction to UML. C++ Constructors.
  
  Read sections 6.2 and 6.3.


• Week 4, first half: Introduction to Inheritance and Polymorphism.
  
  Read sections 16.1 and 16.2.


• Week 4, second half: More on Inheritance and Polymorphism. Abstract Data Types. C++ Templates.
  
  Read section 16.3 and chapter 14. Read the CS 12 Readings (extra reading material, not required).


• Week 5, first half: Classes and Dynamic Memory Allocation, Destructors. Operator Overloading, Friends, and References.
  
  Read sections 10.4 and 12.3, and chapters 9 and 8.


• Week 5, second half: Linked Lists. Final Exam.
  
  Read chapter 15.

Lab schedule

• Week 1:
  Tuesday: Intro to Linux.
  Thursday: Basic programming tools.
  


• Week 2:
  Tuesday: Array Exercises
  Thursday: Recursion
  


• Week 3:
  Tuesday: Course Evals & The Debugger
  Thursday: Vectors
  


• Week 4:
  Tuesday: Lab Practical - Workday.
  Thursday: Maintenance
  


• Week 5:
  Tuesday: Lab Practical - The Static Keyword.
  Thursday: Pointers & Arrays. - Final Review.
  

Material available for download:

• Handouts:
  
  1: Introduction to computer organization pdf
  2: Introduction to stacks and activation frames pdf


• Lecture slides:
  
  Please do not download all slides at once at the beginning of the quarter, for I am still working on improving them and they're likely to change. The best strategy is to download the slides as needed a few hours before the lecture. I will let everyone know if and when the slides are changed.
  
  Lec 1: pdf / pps
  Lec 2: pdf / pps
  Lec 3: pdf / pps
  Lec 4: pdf / pps
  Lec 5: pdf / pps
  Lec 6: pdf / pps
  Lec 7: pdf / pps
  Lec 8: pdf / pps
  Lec 9: pdf / pps
  Lec 10: pdf / pps
  Lec 11: pdf / pps
  Lec 12: pdf / pps
  Lec 13: pdf / pps


• Demos:
  
  1: The Towers of Hanoi puzzle, implemented as both an applet and a stand-alone java application. This demo requires Java 1.2 or higher. html / jar


• Homework assignments:
  
  HW 1 (due on Wed, 07/30)
  HW 2 (due on Mon, 08/04
  HW 3 (due on Wed, 08/06)
  HW 4 (due on Mon, 08/11)
  HW 5 (due on Wed, 08/13)
  HW 6 (cancelled)
  HW 7 (due on Mon, 08/25)


• Home programming assignments:
  
  Full information on these assignments is available here.
  
  1: Addition (due on 8-2)
  2: Cipher (due on 8-3)
  3: Sentences (due on 8-7)
  4: Recursion Exercises (due on 8-10)
  5: Mastermind (due on 8-14)
  5: Calculator (due on 8-14)
  6: Towers of Hanoi (due on 8-17)
  7: Merge Sort (due on 8-21)
  7: Shapes (due on 8-21)
  8: Fractals (due on 8-24)
  8: Fractions (due on 8-24)
  9: Fibonacci Table (due on 8-27)
  10: Linked List (due on 8-29)
  
  Note that the due dates for Assignments 9 & 10 are earlier than other weeks.


• Quiz solutions:
  
  quiz_1_sol.pdf
  quiz_2_sol.pdf
  quiz_3_sol.pdf


• Exam solutions:
  
  midterm_sol.pdf

General course policies (please read these carefully)

• Grades: Current grades will be posted here as frequently as possible. It is your responsibility to ensure that your grades are correct.


• Operating system: All homework assignments and exercises are to be developed under Linux. Questions on how to move assignment files from Windows to Linux will not be answered. Further, if we have reason to suspect that assignments were developed under Windows, your assignment will be docked 25%.


• Compiler flags: In an attempt to wean people out of bad/nonstandard programming habits, the following compilations flags will be used with g++ for all submissions:
  
  -W -Wall -Werror -pedantic
  
  Any submission that does not compile with these flags will be sent back for resubmission, or docked 10%.


• Material covered: Lecture doesn't cover all required material, which also appears in the course books and may be covered only in the lab sessions. You are responsible for retaining knowledge from the required reading and from the lab sessions.


• Assignment Proficiency: For all assignments made up to the last week of the course, a grade of less than 50% functionally will cause the assignment to be sent back for corrections.


• Academic dishonesty: cheating will be strongly punished (typically with an F in the course and an official letter in your student file). All incidences of cheating will be brought up with the Dean of Academic Affairs.
  
  You can report cheating anonymously at: https://www.cs.ucr.edu/cheating/. Assignment submissions must represent your original work, from this quarter. Copying from any sources (web, other books, past or current students, etc.) is strictly prohibited -- learning to program requires you to learn to figure things out by yourself; using existing code and other resources becomes important later on in your studies. While discussing assignments together 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. 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!
  
  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 makeup 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).


• Cell phones: During lectures and lab sessions, please turn off your cell phone. We reserve the right to penalize the grade of repeat offenders. If there is anything so pressing as to require your phone to be on during class, you probably should be somewhere else other than in class.


• Lab attendance: To recieve full credit for lab, you must attend for the full 3 hour period. If you finish the required material early, work on a programming assignment or read the text. Surfing the Internet or chatting with friends are not valid uses of lab time.
  
  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.


• 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. The same policy will apply to the midterm and quizzes.


• Regrade policy: corrections 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. You should not ask the instructor how far you were from a cutoff and what extra work you can do to improve the grade.


• 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 and all such changes.


• Communicating with the instructors and TAs: when sending electronic mail to the instructors or TAs, include in the body of your message your full name, student ID number, and UCR email address. Keep in mind that there may be several students with names almost identical to your own, so proper identification is essential for a prompt reply. Also, please try to be polite and use reasonable grammar and formatting.


• Homework and lab reports: All turned-in assignments must be turned in electronically. Every part of your assignment (every file) must begin with our report template header. Source code must comply with professionally accepted coding style 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, must be there, and help, but they are not a replacement for an explanatory section. In addition, 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. Do not leave your programming assignments to the last minute.


• Reading: Read the current book sections before coming to lecture or lab session, and attend all lectures in their entirety. To encourage these important college study habits, we may give a few pop quizzes during the quarter, at any time during lecture.


• A+'s may be given to students submitting all required material and possibly turning in extra (quality) material (typically lab-related) going beyond the course requirements.


• Success in computer science courses requires time. A typical student needs to spend 12-16 hours per week (twice as much for summer offerings) on this course (including lecture and lab). For your own benefit, please allocate that time.

Course email list

Additional Resources

• GNU Emacs Reference Card (pdf).
• Anwar Adi's Intro to programming tools in Linux page.


• Books
  
  • C++ in a Nutshell pre-release web page.
  • Software Craftsmanship - The New Imperative.
  • Practical C++ Programming.

© 2003 UC Riverside Department of Computer Science & Engineering. All rights reserved.