CS122/504 Progress Log
                            Lixin Tao
                           Spring 2006

Week 1:

    1/24:  
      Introduce Eclipse: workspace, project, class; debug and tracing.
      Review chapter 6 Objects and Classes: 
        class vs. instances; 
        class composition: field vs method; 
        accesibility: public vs private; constructor; this; null; 
        toString(); getter and setter;
        constructor and method overloading;
        reference variable and object aliases;
        passing object as parameter;

      Reviewed classes: Circle, Rational, MethodOverloading, ObjectParameterPassing,
        Aliases, 

      Reading assignment: Chapter 6 of textbook.
        
    1/26:
      Review chapter 6 Objects and Classes: 
        array of objects;
        static field and method; 

      Reviewed classes: StaticDataMember, ArrayOfObjects

      Eclipse exercises: 
        Create program HelloWorld.
        Create class Square.
        Debugging programs.

Week 2: 

    1/31:
      Review the concept of a stack and its implementation with array.
      Array-based stack implementation which can increase array size automatically.
      The usage of java.util.Vector<String>.
      The application of stacks in solving the well-nested scopes problem.

      New classes covered:
        StackOfInter, BalancedScopes (application of Stack)

      Class projects:
        Students first developed a simpler StackOfInteger themselves before we cover
          the full-fledged version in which array size can extend automatically.
        Students developped their own Vector class: MyVector.

    2/2:
      Singly linked lists. 
      Stack implementatin with linked list.
      Solve palindrome character string problem with stack.

      New classes developed together: Node, ListStack


Week 3:
    2/7:
      Queue and its implementation with array.
      Priority queue and its implementation with array.

      Class projects:
        Declare a class IntegerQueue to implement a First-In-First-Out (FIFO) queue of integers.
        Declare a class IntPriorityQueue to implement a Whatever-Order-In-Largest-Out-First 
          priority queue of integers.

    2/9:

      Class inheritance review: motivation, constructor 
        chaning order, method overriding, base reference 
        variable holding reference for derived objects, 
        type casting, operator "instanceof"
        
      Class project: first write class Stack for stack of Object,
      then derive from it a new class IntStack. 
      Note: When overriding a method, the new version cannot
      have a different type. Pay attention to pop() and
      intPop().

      Reviewed classes: Inheritance

Week 4:
    2/14:

      Interface class review.

      Class project: write interface Iterator; write class VectorWithIterator for 
        implementing interface Iterator; and write class PriorityQueueWithIterator
        for implementing interface Iterator. Confirm that through an Iterator reference
        variable only the methods defined in the interface can be accessed.

      Reviewed classes: InterfaceDemo

    2/16:

      Review on Java interfaces.
      Abstract class and polymorphism review. Class constructor chaining. Class finalizer chaining.
      Polymorphism review.
      Explicit call of garbage collector.
      Accessibility: all combinations with a table: 
        Rows: entities to be accessed: public, private, protected, package access.
        Columns: accessing from where: same class, diff unrelated class in the same package,
                 diff derived class in the same package, diff unrelated class in diff package,
                 diff derived class in diff package.

      Class project: ConstructorFinalizerChaining;
        Interface impelmentation: Student, Graduate, Undergraduate, TestInterface;
        abstract class impelmentation: Student2, Graduate2, Undergraduate2, TestAbstractClass;
        
      Worked on accessibility exercises based on a set of classes in packages p1 and p2. Exercised
      on how to see visibale fields/methods from a reference variable in Eclipse.

Week 5:
    2/21: 
      Review and enhancement on Exception Handling. Complete coverage of Exception Handling.
      Introduction to muti-threading: motivation, time-sharing, composition of a thread, 
        thread vs. process, declaring a class for running in a separate thread by inheriting
        base class Thread or implementing interface Runnable, and how to launching a 
        new thread.

      Reviewed classes: ShowException, TestThread.

    2/23:
      Quiz 1

Week 6:
    2/28:
      Review of multithreading programming.
      Introduce thread synchronization problem, synchronized methods and synchronized blocks.
      Covered classes PiggyBankWithoutSync and PiggyBankWithSync.
      Demonstrated the running of class ThreadSynch (no source code review).
      Introduction of Java networking: IP address, how to find your PC's IP address, gateway,
      URL, DNS, port, socket abstraction, class ServerSocket and Socket, thread group, and
      client-server communication through writing to and reading from I/O streams derived from
      sockets.
      Patially covered class: AreaServer.
      Setting up course project teams 1 and 2.

    3/2:
      Review networking programming fundamentals.
      Review class StringTokenizer and String.split(). Review class StringTokenizerDemo.
      Complet coverage of class AreaServer and AreaClient.
      Assignment 2 posted.

Week 7:
    3/7:  School closed due to snow

    3/9:  
      Introduced Java enum types and class EnumeratedTypeDemo.
      Introduced basic concepts of databases, JDBC and ODBC, how to set up an Access System Data Source 
        in windows, and how to use a Java class TestAccessSql to create a database table and 
        inserting/enquirying data through SQL.
      Cover common.Message and enu Command of Pace Instance Messenger.

Week 8:
    3/14:
       Linked list manipulation, recursive methods for finding the length, printing nodes, and reversing 
         a linked list.
       Complete coverage of classes server.PimServer, server.Communicator, and server.Controller.
       Demo how to generate Java Doc in Eclipse.
       Assignment 3 assigned.

    3/16:
       Complete coverage of PIM client side classes.
       Cover GUI programming basics: langout managers. Example code of
        Daniel Liang's book Listings 11.1-4.

Week 9:
    3/28: Review of all fundamental concepts for Java programming

    3/30: Review of all fundamental concepts for Java programming ...

Week 10:
    4/4:  Supervised team project meetings and discussions

    4/6:  Supervised meetings for team project design and implementation

Week 11:
    4/11: Supervised meeting for bridging GUI with PIM business core

    4/18:  Quiz 2

Week 12:
    4/20:  Event-driven programming and Java GUI programming

    4/25:  Java GUI programming with Borland JBulider 2005

Week 13:
    4/27:  Course project demo and presentations

    5/2:   Final exam