CSC 112

Course Syllabus:  CSC 112 Computer Science II

Java Programming and Data Structures

Course Description and Overview

This is the second programming course in the required Computer Science major sequence. It addresses more advanced programming techniques using the Java programming language, and will examine in detail a selection of useful data structures. We will also learn some additional useful tricks with the Unix operating system.

This is a programming intensive course. There are weekly lab and homework assignments and a final programming project, totalling 70% of the grade. Many resources (professor, TA hours, textbook, Web) are available to assist you in completing the coursework, and you are expected to take advantage of them even if you are already doing well. It is imperative that you do not fall behind in the programming assignments because this most often leads to dropping the course. Two exams (midterm and final) will test mostly theoretical knowledge of the concepts presented.

Areas of Study

Course Materials

You will need two books for this class: one covering Java, one covering data structures. The following are recommended, and are available at the college bookstore:

For Data Structures:
Schaum's Outline of Data Structures with Java, Second Edition, by John R. Hubbard.
For Java:
Murach's Java SE 6: Training & Reference, by Joel Murach and Andrea Steelman [Web Site]
Also recommended:
Data Structures and Algorithms in Java, Second Edition, by Robert LaFore. (a little more expensive, but more complete than Schaum's)

Plan to hang on to these books, so you can brush up your skills later on and teach yourself new ones. Additional Java reference books are available in McConnell 104 and 209. These should not be taken out of the lab.

Requirements

Normally students will be expected to take CSC 111 before this course. Students who have taken an equivalent programming course or who have otherwise achieved the requisite programming skills should consult the instructor.

Expected work includes:

This is a programming-intensive course, designed to take neophyte programmers and turn them into nascent software engineers. While programming is one of the most interesting, challenging and rewarding intellectual activities out there, it is almost impossible to learn it without a lot of practice. This takes time, especially for debugging a program you think should be finished that isn't yet working right. If you get easily frustrated by the amount of time spent debugging, you should see me very soon -- before it becomes a problem. I can help you find strategies to use your time effectively. Don't allow yourself to fall behind early in the course; it will be many times harder to catch up later!

Learning to program requires dedication and hard work. Students are expected to complete the assignments for this course by themselves, and will not benefit from relying too much on others. Therefore, each student will be expected to follow this guideline: nobody should see your code on a programming assignment except yourself and the members of the course staff! By extension, you should not see anybody else's code either. Sharing code or working together on assignments is a violation of course policy and may result in a referral to the Honor Board. Similarly, taking code found from other sources (such as the internet) and representing it as your own is dishonest and uniformly prohibited.

Many forms of collaboration are specifically encouraged, subject to the overall restriction noted above. On labs (as opposed to individual assignments), students are encouraged to help each other, so long as each ultimately completes the lab work for herself. Students may discuss algorithms, approaches, and issues that arise in a programming assignment without reference to specific code. They may also discuss any programs and code not directly related to the solution of a programming assignment. In this manner, students may assist each other while ensuring that each ultimately completes the assignments for herself.

Grading

For the final grade, you have the option to choose one of the homeworks - presumably the one with the lowest grade - which will be dropped from the final average computation. However, you can only choose to drop a homework for which you did the work. If you miss a homework you will receive a failing grade, and that grade may not be dropped. (Students may wish to view the instructor's policy for computing averaged grades.)

General Grading Guidelines:

  1. Your program must compile. Avoid submitting code that does not compile, as it will receive at most a grade of C (if it at least resembles a possible solution to the problem -- else it will be an E).
  2. It is better to submit a program that works than one which crashes, even if you have not implemented all the required features. Keep intermediate versions of your programs in separate directories, and if you do not have time for last minute debugging, submit the last version that (at least partially) worked.
  3. The way you document your program affects your grade: be generous with pertinent comments! Students will be expected to meet the documentation standards described in class.
  4. The majority of the grade reflects the functionality of the program (whether or not it works), but approximately 20% will be based upon the program design. Elements of good design include the proper use of program documentation, the quality of the user interface (if required for the assignment), and cleanness and elegance of programming style.
  5. Throughout the semester, interspersed with the technical aspects of programming and theory (data structures), I will teach you simple software engineering principles, which convey discipline to the art of programming. Class attendence, participation in discussions regarding possible solutions, self-study discipline, good organizational skills are your key to mastering programming and avoiding lengthy debugging sessions. Your final grade will also have to reflect and reward these qualities, and the work on the final project will be the best indicator.
  6. To summarize: A level work means quality programs which run, do what they are supposed to do, are well designed and documented and submitted on time. Small stylistic or technical imperfections in an otherwise excellent program may make the difference between an A grade and an A- or other lower grade.

Lab, Homework and Lateness Policy

Labwork is designed to be completed during the scheduled lab time. If for some reason you are left behind or want to redo the work later at your own pace, you have to submit everything by midnight the same day. The lab should not interfere with your work on the programming assignment.

All homework is assigned on Tuesdays and is due the following Monday by midnight. Students are expected not to share code related to homework assignments.

No late homework will be accepted, except at the instructor's discretion for documented extenuating circumstances. You should submit, by the midnight deadline, the homework solution reflecting your work on it up to that point. Note that the homework submissions will be electronically collected at the project deadline.

The final project is due before the last class (Thursday, May 1, 10:30 am). No late submissions are accepted.


Course Details

Professor:
Nick Howe
McConnell 215
585-3878

Office hours
Teaching Assistants:
Meeting Times:
Lecture: Burton B17, 10:30-11:50 Tuesdays & Thursdays
Lab: Burton B01, 1:00-2:50 Tuesdays