Recommendations for Teaching
CSCE 144 - Introduction to Computer Science
At Pacific Lutheran University

General guidelines:

• Fundamentally, this is a Java programming course.
• Our philosophy is an objects-early approach. Topics such as problem solving using top-down design strategies, methods and parameter passing, fundamental control structures, variables, types, mathematical expressions, using classes and objects, and understanding API documentation, should be covered before students begin to design and use Java classes of their own.
• Eliminate all but the essentials.
• We recommend that you include a component involving student presentations and discussions of broad CS and ethics topics. A possible format might be 15 minute group presentations that take place frequently (perhaps weekly). We recommend that some ethics topics such as intellectual property, be covered.
• Be sensitive early on to students of various backgrounds. We recommend some time early on be spent covering basic file system skills, and understanding file system layouts.
• GUIs are fun, and we encourage teaching them, but keep the number of "frills" low. The GUI design should take a back seat to basic problem solving.
• We recommend that labs include an instructional component as well as time for individual work.

Outcomes

The following are the skills that we expect 144 "graduates" to have.

• Students should be able to write programs using both console and GUI I/O. (The exclusive use of applets in this course is not encouraged.)
• Students should be able to write programs that do I/O using the following schemes:
• Read input from a GUI (J)TextField, and respond via a (J)TextArea or JOptionPane. (Note that output via the console is discouraged when getting input in this fashion.)
• Respond (and read) input from the console (System.in). (Output to System.out)

We suggest that you have each type of I/O in one or more lab assignments.

• Students should be able to design, implement, and use a simple class of their own without explicit inheritance.
• Students should be comforatable reading the documentation for the standard Java API classes. They should understand inheritance, encapsulation, and information hiding at least in this context.
• Students should be able to apply basic algorithmic patterns to solve problems.

Example syllabus

These topics are in recommended order, however it is not necessary to cover them exactly in this order. We recommend that problem solving be incorporated throughout.

1. The computer and its components. Brief history of programming languages.
2. File systems, files.
3. The Java compiler. (edit-compile-run cycle)
4. Variables, types, expressions, assignment operator, basic math operations, Strings.
5. Object variables vs primitive data types. (References) Object and class diagrams using pseudo-UML syntax is recommended.
6. Boolean logic/variables. Truth tables.
7. The if statement. (flowcharts)
8. Methods and parameters, top-down design (iterative refinement).
9. GUI design and event handling.
10. Looping structures (while, do-while, for). Flowcharts.
11. Case analysis.
12. Testing and test cases.
13. Debugging
14. Arrays
15. Linear and binary search.
16. Quadratic sorting algorithms.
17. Basic class design.

Desirable additions:

• Recursion
• 2D graphics (drawing shapes, charts, etc.)
• Exceptions and text file I/O
• Regular expressions.