CPSC 124 Introduction to Programming Spring 2009

CPSC 124 Course Information

Course Description

Programming is the art and science of explaining to a computer how to carry out a task. The art is in constructing something that not only works, but is also beautiful - efficient, elegant, and organized. The science comes from developing (and making use of) theory and principles to help programmers create larger, more complex programs.

Programming is at the heart of computer science, but it is not all of computer science. Programming requires creativity, logical thinking, and problem-solving skills. It can be frustrating when you are trying to track down why your program isn't quite working right, but it is even more rewarding when you finish and can point to your creation.

This course is an introduction to the theory and practice of computer programming, emphasizing techniques of program development in the object-oriented paradigm. The course is taught using Java, a relatively new language which has grown in popularity due its Web-friendly characteristics. Standard topics such as control structures, subroutines, objects, and arrays are covered. Attention will also be given to "how to think like a programmer" - that is, the fundamental logical thinking and problem-solving skills which are independent of the particular language being used.


Stina Bridgeman
Lansing 312, x3614

Course Web Page

You are expected to regularly consult the course web page for announcements, assignments, and most handouts.


Introduction to Programming Using Java, 5th ed. (Part I)
David Eck

The book is available online at http://math.hws.edu/javanotes/.

You will probably find it convenient to also have a printed copy of the text for easy reference during class. Printed copies can be ordered from lulu.com: http://www.lulu.com/content/559884. We'll only be using chapters 1-7, so make sure you order (only) Part I. Please do not print out chunks of the text on the Math/CS department printers.

Additional material will be handed out or posted on the course webpage.


No prerequisite, though CPSC 120 or equivalent experience is recommended. Some familiarity with computers is useful.

Rationale, Aims, and Objectives

Computer science revolves around programs - creating programs, analyzing programs, making programs more efficient and easier to understand, making it easier to create and maintain programs, considering what programs can and cannot do...the list goes on. As a consequence, one of the first courses in computer science is typically a programming course. Such a course has two goals: the most obvious, perhaps, is to teach the rules and grammar of a particular programming language so that programs can be constructed. Somewhat less obvious is teaching how to think like a programmer - how to take an idea of what you want to do, and turn it into a series of steps the computer can follow. This requires logical thinking and problem solving. These skills are more fundamental to programming than the particular language involved, and are useful even for those who have no intention of becoming programmers or computer scientists.

Like a single semester of a foreign language course, this course will not teach you everything you need to know to be a good programmer and and it won't even teach you everything there is to know about Java. You will, however, learn enough to be able to create interesting and useful programs, and you will have a solid basis for continuing your study. (Shameless plug for CPSC 225 and 329 here.)

This course has five main goals:

  • developing a solid grounding in the fundamental concepts of object-oriented programming, including data types, variables, conditionals, repetition, arrays, subroutines, and classes and objects
  • developing fluency in basic Java syntax and semantics
  • establishing good programming habits
  • building confidence about what you do and don't know, and the knowledge of how to learn what you don't know
  • building excitement about programming as a creative art, and computer science as a field of study

By the end of the course, the successful student will be able to:

  • frame the solution to straightforward tasks in terms of object-oriented programming concepts, and translate that solution into Java code
  • correctly trace any Java code that uses the constructs studied in class
  • take steps to resolve compiler, runtime, and logic errors independently
  • navigate a Linux environment (manage files, use a text editor, compile and run programs)
  • identify what she/he does and doesn't know about a task at hand, and take steps to address what isn't known

Course Content Overview

The course material can be divided into three sections: the basics of the Java language and Java programs, object-oriented programming with Java, and applets and graphical user interfaces.

Programming Basics: The first part of the course will deal with many of the basic building blocks of programming. The Java language will be introduced, along with programming concepts such as types, variables, assignment statements, expressions, conditionals, loops, subroutines, functions, parameters, return values, I/O (input/output), and arrays. Specific objectives include:

  • understand the procedural programming paradigm
  • be able to read a Java program and explain how the computer executes each statement
  • be able to write a Java program given a pseudocode or detailed English description of what the program should do
  • be able to use top-down design to develop pseudocode for a well-structured program given English specifications for the program's task
  • know the syntax for creating and manipulating arrays
  • be familiar with common uses for arrays

Object-Oriented Programming: The second part of the course will introduce the object-oriented paradigm, and will introduce the concepts central to object-oriented programming: classes, objects, instance variables and methods, inheritance, and polymorphism. There will also be an increasing amount of attention paid to the design and organization of good programs. Specific objectives include:

  • understand the object-oriented programming paradigm
  • be able to read a Java program involving objects and classes, and explain how the computer executes each statement
  • be able to write a class declaration
  • be able to write an object-oriented program given a pseudocode or detailed English description of what the program should do
  • produce a class design and pseudocode for a well-structure program given English specifications for the program's task
  • use a new class given an API describing how it works

Applets and GUIs: One of the features which has made Java popular is the ease with which programs can be integrated into Web pages. Java programs embedded in Web pages are known as "applets". This part of the course will address how to create applets and the graphical user interfaces (GUIs) which applets and most other modern programs provide, and will introduce the "event-driven" mode of programming. Specific objectives include:

  • understand the structure of event-driven programs
  • be able to use AWT painting routines to draw pictures
  • be able to write an applet including basic Swing components and custom components, and which responds to mouse motion, mouse clicks, key presses, and other events

Team-Based Learning

Memorizing the syntax and semantics of Java is important for being a good programmer, but that's not the only thing - being a good programmer is really about being able to use the language to express yourself. Successful programmers must be able to take what they know about variables and loops and conditionals, and figure out how to use those tools to solve a particular problem. Getting good at this takes practice and experience, and is something best learned by trying and doing rather than simply reading about it or watching someone else tell you about it.

To address this issue, this course will use a team-based learning approach. There are two key aspects to this approach:

  • Class is primarily spent doing (working on activities and problems), not listening to lectures.
  • Much of the in-class work and some out-of-class work is done in teams.

Working on activities and problems which ask you to apply knowledge means that you must already know the fundamental concepts. To address this, each unit of the course will have a several-day "readiness assurance process" before getting down to application-oriented exercises. The goal of the readiness assurance process is to make sure everyone understands the fundamental concepts of the unit. The readiness assurance process works like this:

  • (before class) Do the assigned reading. This introduces the new topics, and a reading guide will be provided with each major reading assignment to help you focus on the important parts.
  • (in class) Take a multiple-choice readiness assessment test (RAT) first individually, and then with your group. This "encourages" you to actually do the reading, and provides feedback on how well you've grasped key points.
  • (in class) Some lecture/discussion will address any misunderstandings or remaining questions from the RAT. The goal is to spend this time on addressing tricky points, not introducing new material for the first time.
  • (in class) For some units, there will be a syntax quiz focused specifically on Java syntax and semantics. This emphasizes the importance of learning these details.

After the readiness assurance process is completed for a unit, several class periods will be spent on group activities designed to deepen your understanding of the material and give you practice applying the new concepts.

A few words on group work, since sometimes the prospect of group work is unpopular (especially when part of one's grade depends on group work):

Teamwork is valuable in many respects. Teams mean that you have the resources to successfully tackle more difficult problems - not everyone in the team will know how to solve every aspect of a problem, but the different skills of each team member means that everyone will have ideas that contribute to the solution. Teams also help overcome some of the frustration of learning to program - errors and roadblocks that arise because the computer demands that you write down everything exactly correctly and in detail, which is difficult for people (even experts) and especially difficult when you are still learning what's right and what isn't.

Teams also contribute to individual learning. Since success of the team depends on individuals being prepared, teamwork fosters individual accountability. Having to reach a consensus on the answer to a problem means that everyone must be able to explain their answers - something which deepens one's own understanding of the material. In addition, participating actively in the process of collaboratively figuring out an answer means that knowledge will stick in your head better than if someone just told you the answer.

Finally, a few comments about the most common complaint about groups - free riders who get pulled along by the extra-hard work of others. Several things address this. Group activities are primarily in-class activities (so there are not scheduling issues) and are activities that benefit from the whole group participating. Individuals are accountable to the group - 15% of the final course grade is based on individual preparation for group work and on individuals' contributions to the team (measured through peer evaluations). 25% of the grade is based on group activities - and groups who work together as a team typically outperform their best individual member. (So there's incentive for everyone to make the group work.) And finally, individuals are also still accountable to themselves - 70% of the final course grade is based on primarily individual assignments. Someone who slacks off in the group will also be less prepared for their own work. (If you add up all the percentages and wonder why you get more than 100%, it's because some things count in several categories e.g. individual RATs are part of the individual grade but also part of individual preparation for group work.)

Valid HTML 4.01!