The course described on this page ended May 7, 2006
You can download a .zip archive of this site at the link:
(Note that where any lab refers to a file in the directory /classes/s06/cs124,
there is also a link to a copy of that file in the archive; the
/classes/s06/cs124 directory itself is not included.)

CPSC 124: Introduction to Programming

   Department of Mathematics and Computer Science
   Hobart and William Smith Colleges

   Spring 2006.

   Instructor:  David J. Eck  (

   Monday, Wednesday, Friday, 1:55 -- 2:50 PM
       Room Lansing 300

   Lab: Tuesday, 10:20 -- 11:45 AM
       Room Gulick 208

   Course Handout:

   Scheduled Office Hours (Room Lansing 301):

                  Monday:     12:30 -- 1:30
                  Tuesday:     1:30 -- 3:00
                  Wednesday:  11:00 -- 12:00
                  Friday:     10:00 -- 11:00

Assignments and other information for CPSC 124
will be posted on this page as the course is taught
during the Spring term of 2006.

Lab Worksheets
Lab 1, January 17
Intro to Linux and Java
Lab 2, January 24
"Once-Through" Programs
Lab 3, January 31
Introduction to Eclipse
Lab 4, February 7
Branches and Loops
Lab 5, February 14
Lab 6, February 21
Writing Subroutines
Lab 7, February 28
Intro to GUI Programming
Lab 8, March 7
Lab 9, March 21
Mosaic, Mousing, and Menus
Lab 10, March 28
Writing a Class
Lab 11, April 4
Components and Networking
Lab 12, April 11
Lab 13, April 18
Work on Projects
Lab 14, April 25
Programming Assignments
Project #1: Random Math Quiz Project #2: Mosaic Draw Continued Final Programming Project
Test and Quiz Answers
Quiz 1, January 25 Quiz 2, February 3 Quiz 3, February 10 First Test, February 17
Quiz 4, March 6 Second Test, March 31 Quiz 5, April 11 Quiz 6, April 24

Some Useful Links

End of Term: April 24 to May 7

In the last week of the term, we will be covering several additional topics from Chapters 5, 6, and 7. The exact topics might depend to some extent on what would be useful in students' final project, but they will likely include: abstract classes and details of inheritance and polymorphism (Section 5.4); nested and anonymous classes (Sections 5.6 and 6.4); additional standard GUI components (Section 7.3); and using off-screen images (Section 7.1). We will probably also spend some time on exceptions and the try...catch statement, which is covered on-line in Section 9.3 but not in the printed version of the textbook.

Final projects are due on the very last day of classes, Tuesday, May 2, in our regular lab period, and students will present their final projects to the rest of the class at that time. We will meet, as usual, in Gulick 208. (Remember that if you are not quite finished your program at that time, you can ask for an extension of a few days, but only if you have a substantial amount of work done and if you present the work that you do have done to the class.)

The final exam will be given during the scheduled final exam period, on Sunday, May 7, at 3:00. The exam will be in our regular classroom, Lansing 300. It will be cumulative, with some emphasis on material covered since the second test. Although a three-hour period is allowed for the exam, it will only be about one-and-a-half times as long as a one-hour in-class test. A review sheet will be available here before the end of classes.

A review sheet for the final exam is available.

Thirteenth Week: April 17, 19, and 21

We will continue studying arrays and their applications this week. The reading is Sections 8.4 and 8.5. Since there are so many projects coming due as the end of the term approaches, the lab will be used as time for work on those projects. You can work on the assignment that is due on Wednesday or, if you have finished the assignment already, on your final project. (You can even work on last week's lab, if you didn't get it finished.) You will get some point for turning up for the lab.

Twelfth Week: April 10, 12, and 14

We will be continuing with arrays for this week and into next week. The reading for the week is Sections 8.2 and 8.3. Don't forget that the second project is due next week and that you should be thinking about the final project and discussing your ideas with me.

Eleventh Week: April 3, 5, and 7

We still haven't done much in Chapter 6, we we will spend some time on that on Monday and Wednesday. By Friday or before, we will start Chapter 8, which covers arrays. The new reading for the week is Chapter 8, Section 1. Arrays will be our major topic for the next few weeks.

Tenth Week: March 27, 29, and 31

There is a test on Friday of this week. A review sheet is available. Also, the second programming project and information about the final project are also available.

The reading for this week is Chapter 6. We have already covered much of this material in the labs, so we will be going through it rather quickly. Any new material in Chapter 6 (that is, material that was not on the labs) will not be on the test.

Ninth Week: March 20, 22, and 24

We will continue with Chapter 5 this week. You should read Sections 5.2 and 5.3. We will also cover a few topics from the remaining sections of Chapter 5, including at least the following: extending existing classes (end of Section 5.4), the special variable "this" (from Section 5.5), and interfaces from the beginning of Section 5.6. We have already encountered the idea of a "class hierarchy," so you should also be familiar with that in a general way. We will cover all the details of Chapter 5 later in the course.

The second test is coming up next week, on Friday, March 31.

Eighth Week: March 6 and 8

We still have to finish up a few details from Chapter 4 on Monday. However, we will quickly be moving on to Chapter 5, on Object Oriented Programming. (In fact, we have already encountered some of the ideas in Chapter 5 from time to time, mostly in relation to the labs. There will be a quiz on Monday on Chapter 4.

There is no class on Friday because of Spring break. Classes resume on Monday, March 20.

Seventh Week: February 27; March 1 and 3

We will finish up Chapter 4. You should read the remaining sections, 4.5 through 4.7. The lab this week, besides letting you do some basic work on subroutines, will serve as an introduction to objects, events, and GUI programming. You should read Lab 7 in advance of the lab. And don't forget that Programming Project 1 is due on Friday.

Sixth Week: February 20, 22, 24

This week, we start Chapter 4. The reading for the week is Sections 4.1 through 4.4. Chapter 4 covers subroutines. This week, we will be covering the basic syntax for writing and calling subroutines. For the time being, we are doing "static" subroutines and member variables. Non-static subroutines and variables, which are used in object-oriented programming, are covered in Chapter 5.

The first programming project is due at the end of next week. The lab for this week is designed to be short enough to finish during the lab period so that you will have time to work on the project.

Fifth Week: February 13, 15, and 17

There is a test on Friday of this week. A review sheet for the test is available.

The reading for the week is the rest of Chapter 3. Note that the parts of Section 3.7 that we are going to cover have already been covered in lab, and we will not be talking about that section in class. We will spend Monday and Wednesday finishing up the remaining control structures (Sections 3.4 and 3.5) and doing examples.

Fourth Week: February 6, 8, and 10

We still need to talk about some aspects of algorithm development from Section 3.2. After that, we will start working through details of Java control structures in Sections 3.3 through 3.6. We will do this mostly by looking at programming examples. I won't spend a lot of time in class dwelling on details of syntax; nevertheless, you need to learn the syntax in detail.

Third Week: January 30; February 1 and 3

The reading for the week is Sections 2.5, 3.1, and 3.2.

Second Week: January 23, 25, and 27

The reading for the week is Chapter 2, Sections 2.2, 2.3, and 2.4. These sections introduce the most basic individual statements in the Java language: variable declarations, assignment statement statements, and subroutine call statements. These are the basic building blocks that we will use to create more complex programs in later chapters. Topics include the basic types of variables and the subroutines that are used for console input and output.

Reminder: There is a quiz on Monday.

First Week: January 16, 18, and 20

Welcome to the course. If you read the course handout, you will see that there is already a quiz scheduled for next Monday, January 23. It will cover Chapter 1 and Section 2.1 of the textbook. It might also include material from the first lab, which takes place on January 17.

You should begin reading the textbook. A printed copy will be available in class on Wednesday, but you can start in any time with the on-line version at The first chapter of the book contains some background material about computers and an overview of programming in general and Java in particular. While you might not understand everything in this chapter at this time, it will be useful to have some overview of the field as you start the course. Chapter 2 is the beginning of the detailed study of Java programming that will occupy us for the rest of the course.

I will know my regular schedule of office hours by Wednesday. For the beginning of the term, I will have office hours Tuesday, January 17, from 1:00 to 3:00 and Wednesday, January 18, from 12:00 to 1:50.