Course Syllabus

This is a highly approximate syllabus. Expect topics, assignments, ordering, and almost everything else to change. Note that there are also a few additional topics that I hope to sneak in.

Week One: Introduction

Class 01 (Monday, January 25) Introduction

• Course overview
• Introduction to data structures and algorithms
• Introduction to programming paradigms
• Assignment: Introductory survey Due before class on Tuesday!

Class 02 (Tuesday, January 26) Introduction to Java

• Due: Introductory survey
• Introduction to object-oriented programming
• An introduction to Java
• Handout (electronic): Using Java in the MathLAN
• Reading: Introduction to Experiments in Java
• Lab: J1: An introduction to Java

Class 03 (Wednesday, January 27) Classes and Objects

• The structure of a class
• Building methods
• Lab: J2: Objects and methods
• Assignment 1 (Calculation) distributed. Due Wednesday, February 3, 1999.

Class 04 (Friday, January 29) More Classes and Objects

• Fields and object state
• Constructors
• Overloading
• Lab: J3: Building Your Own Objects

Week Two: Object-Oriented Programming

Class 05 (Monday, February 1) Even More Classes and Objects

• Lab continued: J3: Building Your Own Objects

Class 06 (Tuesday, February 2) Conditionals

• Boolean values and expressions
• The if statement
• The switch statement
• Lab: J4: Boolean Expressions and Conditionals
  • Experiments: J4: Boolean Expressions and Conditionals

Class 07 (Wednesday, February 3) Loops

• Repetition
• for loops
• while loops
• Assignment 1 due (optional).
• Assignment 2 due.
• Lab: J5: Control Structures for Repetition

Class 08 (Friday, February 5) Building Graphical Programs

• Applications and Applets
• The AWT
• Drawing commands
• Assignment 3 distributed. Due Friday, February 12.
• Lab: G1: Graphics and Applets

Week Three: Java Wrapup

Class 09 (Monday, February 8) When Things Go Wrong

• Design: How to handle and check errors
• Exceptions: Java's primary error-handling mechanism
• ``Primitive'' classes: Integer, Double and friends.
• Lab X3: Input, output, files, and exceptions

Class 10 (Tuesday, February 9) Inheritance and Interfaces

• Code reuse
• Core issues in object-oriented programming
  • Inheritance
  • Polymorphism
• Interfaces
• It is likely that this class will primarily emphasize lecture and discussion, with no in-class laboratory component.
  • You are encouraged to read through and think about O2: Inheritance and O3: Interfaces, but are not required to do those labs.

Class 11 (Wednesday, February 10) Java's Abstract Windowing Toolkit

• Java's abstract windowing toolkit (AWT)
• Event-driven programming
• Lab: G2: Java's Abstract Windowing Toolkit.

Class 12 (Friday, February 12) Java's Abstract Windowing Toolkit, Revisited

• Lab: G3: The AWT, Continued.
• Due: Assignment 3: A Graphics System.
• Assignment 4: Assigment 4: Testing the Fraction Class distributed. Due Friday, February 19.
• Optional assignment 5: A Simple Drawing Application distributed. Due Friday, February 19.

Week Four: Algorithm Analysis

Class 13 (Monday, February 15) Documentation and Testing

• Documentation and Javadoc
• Testing: why and how
• Preconditions and postconditions
• A sequence class

Class 14 (Tuesday, February 16) Arrays and Sequences

• Compound data types
• Arrays
• Sequences
• Lab: J6: Arrays
• Reading: Java Plus Data Structures, Section 4.1 (if available).

Class 15 (Wednesday, February 17) Algorithm Analysis

• Basics of algorithm analysis
• Searching algorithms
• Reading: Java Plus Data Structures, Section 4.6: Algorithm analysis

Class 16 (Friday, February 19) Recursion

• Exam 1 distributed. Due Friday, February 26.
• Introduction to recursion.
• Lab (read in advance): A1: Recursion.
• Due: assignment 4: A Testing Program
• Due: assignment 5 (optional): A Simple Drawing Program

Week Five: Recursion

Class 17 (Monday, February 22) Binary Search

• Laboratory: A2: Searching

Class 18 (Tuesday, February 23) Recursion, Revisited

• Selected recursive algorithms
  • Factorial
  • Exponentiation
• Algorithm design techniques
  • Divide and conquer
• Reading: Java Plus Data Structures, Chapter 5: Recursion.

Class 19 (Wednesday, February 24) A Stamp Problem

• Algorithm design techniques
  • Greed
  • Dynamic programming
• Applications
  • Fibonacci numbers
  • Computing stamps

Class 20 (Friday, February 26) Sorting Algorithms

• The problem of sorting
• In-place vs. out-of-place sorting
• Selection sort
• Insertion sort
• Reading: Java Plus Data Structures, Chapter 11 (which won't be ready until late in the semester).
• Exam 1 due.
• Assignment 6 (Algorithm Analysis) distributed. Due Friday, March 5.

Week Six: Sorting

Class 21 (Monday, March 1) More Efficient Sorting Algorithms

• Merge sort
• Quick sort
• Other sorting techniques

Class 22 (Tuesday, March 2) Sorting Lab

• Laboratory: Sorting

Class 23 (Wednesday, March 3) Special Discussion

Class 24 (Friday, March 5) The Design of Lists

• Introduction to lists
• Lists vs. arrays
• Unordered lists
• Ordered lists
• Sorted lists
• Reading: Java Plus Data Structures, Chapter 4 (Not available)

Week Seven: Lists

Class 25 (Monday, March 8) Discussion of Exam 1

• Exams returned
• Handout: Notes on exam 1
• Assignment 6 (Algorithm Analysis) due.
• Assignment 7 (Sorting) assigned.

Class 26 (Tuesday, March 9) Implementing Lists

• Techniques for implementing lists
  • Arrays
  • Nodes
• Specification vs. implementation: does a sorted list really have to be sorted?

Class 27 (Wednesday, March 10) Vectors

• Vectors
• Vectors vs.
  • lists
  • arrays
  • sequences
• Lab: X2: Vectors

Class 28 (Friday, March 12) Linked Lists

• Selecting a core set of list operations
• Lists in Java vs. Lists in Scheme
• Lists vs. nodes
• Dynamic-sized lists.
• Supporting additional list operations.
• Reading: Java Plus Data Structures, Chapter 6
• Reading: Java Plus Data Structures, Section 8.3
• Exam 2 distributed. Due Friday, March 19.

Week Eight: Design

Class 29 (Monday, March 15) Lists, Concluded

• Other issues
• Assignment 7 (Sorting) due.

Class 30 (Tuesday, March 16) Object-Oriented Design (1)

• Program design
• Core aspects of object-oriented programming, revisited
  • Inheritance
  • Polymorphism
• Designing objects
• Lab: O1: Design

Class 31 (Wednesday, March 17) Object-Oriented Design (2)

• Today, we may also pick an interesting problem and look at design issues
  • Which objects
  • Which methods
  • Reuse

Class 32 (Friday, March 19) Animation

• Today's class is intended to be fun (we all need fun right before break): we will consider animation in Java.
• Animation lab

Break

Break runs from 5:00 p.m. on Friday, March 19, 1998 to 8:00 a.m. on Monday, April 5.

Week Nine: Machine-Level Issues

Class 33 (Monday, April 5) Introduction to Machine Representation

• Fundamental types
• Nonnegative integers

Class 34 (Tuesday, April 6) More Binary Representation

• Characters
  • ASCII
  • UNICODE
• Real Numbers
• The IEEE Standard
  • Reading IEEE standard representation of reals

Class 35 (Wednesday, April 7) Other Machine-Level issues

• Due: Exam 2.
• Representing images
• Representing objects
• Run-time issues
  • The stack and the heap
  • Garbage collection
• Possible visitation from prospectives

Class 36 (Friday, April 9) Design, Revisited

Week Ten: Linear Structures

Class 37 (Monday, April 12) Introdution to Linear Structures

• Linear structures
  • Meaning
  • Core operations
  • Types of linear structures
• Three kinds of linear structures:
  • Stacks
  • Queues
  • Priority queues
• Reverse polish notation
• Reading: Java Plus Data Structures, chapter 7.

Class 38 (Tuesday, April 13) Stacks

• Implementing stacks

Class 39 (Wednesday, April 14) Stack lab

• RPN calculation
• dc
• Lab: Stacks

Class 40 (Friday, April 16) Linear Structures for Solving Puzzles

• Possible visitation from prospectives
• What is a puzzle?
• What are strategies for solving puzzles?
• How can linear structures help?

Week Eleven: Dictionaries

Class 41 (Monday, April 19) Dictionaries

• The dictionary ADT.
• Implementations of dictionaries
  • Lists
  • Search trees
  • Hash tables
• Uses of dictionaries
• Reading: Java Plus Data Structures, chapter 9.

Class 42 (Tuesday, April 20) Hash Tables

• Implementing dictionaries with hash tables
• Java's java.util.Hashtable class
• Design decisions in hash tables
• Hash functions

Class 43 (Wednesday, April 21) Project Discussion

• Problems with summaries
• Narratives for improving design

Class 44 (Friday, April 23) Project Discussion, Continued

• Possible visitation from prospectives

Week Twelve: Trees

Class 45 (Monday, April 26) Introduction to Trees

• Representing arithmetic expressions
  • And evaluating them
• Generalizing search trees and arithmetic expression trees: a Binary Tree ADT
• Generalizing binary trees: a Tree ADT

Class 46 (Tuesday, April 27) Heaps and Heap Sort

• Implementing trees with arrays
• Heaps, an implementation of priority queues
• Heapsort, sorting using heaps
• Code templates due.

Class 47 (Wednesday, April 28) Lab: Traversing and Iterating Trees

• How do you visit/iterate/list the elements of a tree?
• Preorder vs. postorder
• Depth-first vs. breadth-first
• Traversal and linear structures
• Lab

Class 48 (Friday, April 30) Design Discussion

• Exam 3 distributed. Due Friday, May 7, 1999.

Week Thirteen: Graphs

Class 49 (Monday, May 3) More Design Discussions

• Design issue: what does listByField return?
• Who "owns" the program we create?

Class 50 (Tuesday, May 4) Introduction to Graphs

• Generalizing the Tree ADT: a graph ADT
• Applications of graphs
• Important graph algorithms
• Implementing graphs

Class 51 (Wednesday, May 5) Reachability

• Reachability: can you get there from here?

Class 52 (Friday, May 7) Reachability, Revisited; Shortest Path

• Testing our algorithm
• The shortest-path problem (revising reachability): You can get there from here. But how quickly?

Week Fourteen: Wrapup

Class 53 (Monday, May 10) Shortest Path, Revisited; Graphs, Concluded

• Dijkstra's algorithm, in depth
• A few more algorithms
• Minimum spanning tree

Class 54 (Tuesday, May 11) History of Computing (1)

• Definitions: computing, computer science, hypertext, etc.
• Changing perspectives of computing

Class 55 (Wednesday, May 12) History of Computing (2)

• A history of pre-computer computing
• Computing since computers
• Some social implications

Class 56 (Friday, May 14) Wrapup

• A definition of computer science, revisited
• Course evaluation
• Wrapup
• Some final statements
• Handout: Notes on exam 3

Final

The final examination for this course is optional. It can be used as a makeup for one examination. Like the other examinations, it will be a take-home examination.

Additional Topics

There are a number of additional topics that I expect to cover, perhaps in the context of another topic already on the outline.

• Object-oriented design.
• Image transformations.
• Animation.
• Testing, debugging, and validation.

History

The history will not include small changes to the summaries of individual classes. You can find more information on such changes in the individual outlines.

Monday, January 18, 1999

• First version, mostly complete in terms of topic list, but not necessarily in terms of daily summaries.

Tuesday, January 19, 1999

• Added additional topics.

Thursday, January 21, 1999

• Updated some information on daily summaries.

Friday, January 22, 1999

• Added a few more additional topics.

Monday, January 25, 1999

• Filled in details on remaining topics.

Tuesday, January 26, 1999

• Added note on small changes at the start of this section.

Tuesday, February 23, 1999

• Updated week titles to reflect compounded changes to the syllabus.