Comp 212: Intermediate Programming
	Spring 2007

COMP 212 - INTERMEDIATE PROGRAMMING SYLLABUS

RICE UNIVERSITY - Spring 2007

INSTRUCTORS:

• Dr. Alan Cox
• Dr. Dung X. Nguyen (pronounced "Zung Gwen", it’s Vietnamese!)

TEXT BOOKS: 

We do not use any text books in this class.

Recommended:

• Head First Design Patterns, 1st edition, by Eric Freeman and Elisabeth Freeman, O'Reilly, 2004.  One of the most user-friendly books on design patterns - Highly recommended.
• The Java Programming Language, 3^rd edition, by Arnold, Gosling, and Holmes,  Addison-Wesley, 2000. ISBN 0201704331  James Gosling is the creator of Java.  This is the definitive Java reference.   However, this book does not cover all the topics of the course and will be used only as a reference for Java syntax and semantics.
• Design Patterns Elements Of Reusable Object-Oriented Software, by Gamma, Helm, Johnson, and Vlissides, Addison-Wesley, 1995. ISBN 0201633612 This is the bible of the pattern community. It predates Java. The authors are affectionately referred to as the Gang of Four (GoF).  All examples are written in C++ and/or Smalltalk. It can be hard to read if you are not familiar with these two languages, though the ideas are language independent. The "pattern language" used in this book also requires a lot of getting used to. We have learned so much from this book, and we are still reading it and learning from it. There is a version on CD-ROM which is cheaper (and perhaps, more versatile). We strongly recommend it, especially to any student considering further work in object-oriented programming.
• Design Patterns Java Workbook, by Steven John Metsker, Addison-Wesley 2002. One of the latest imitation of the GoF's book using Java and Java GUI components as examples.
• Java Design Patterns, A Tutorial, by James Cooper, Addison-Wesley 2000.  Another imitation of the GoF's book using Java and Java GUI components as examples.
• Patterns in Java, John Wiley & Sons, 1998, by Mark Grand.  Another imitation of the GoF's seminal book.
• Graphic Java 2, Mastering the JFC 3rd edition, by David Geary, Sun Microsystems Press, 1999.  This is by far the most well-written book on writing GUI applications in Java.

  COURSE PREREQUISITE:

  Comp 210 – programming concepts and design recipes taught in Comp 210 will serve as part of the foundation of object-oriented programming (OOP).

  COURSE DESCRIPTION:

  This course provides the transition from the functional paradigm (Comp 210) to the object-oriented paradigm. It introduces OOP using Java as the implementation language. It emphasizes proper formulation and abstraction of the problem domain in the programming process in order to build programs that are robust, flexible, and extensible. It teaches how design patterns help formulate and implement abstractions in effective and elegant ways.

  The course covers data structures and algorithms to manipulate them that are essential to programming, such as lists, stacks, queues, trees, tables. These structures are implemented as systems of cooperating objects using appropriate design patterns. The course will also cover both stream I/O and event-driven I/O. Since the textbooks do not systematically present these topics, additional lecture notes will be provided.   As such, class and laboratory attendance is mandatory!

  Programming assignments are designed to help understand how the above concepts are implemented and used in various situations. These assignments constitute as an integral part of the course. They can be very time-consuming and require that you start working on them early and budget your time wisely.

  Laboratory sessions serve to complement the class lectures and provide a highly interactive environment where students can work in small groups to explore and discuss new topics,  topics presented in the lectures, and problems that may arise from the assignments.  Attending and actively participate in the lab discussions will help you succeed in the course.

  COURSE OBJECTIVES:

  Upon successful completion of the course, the students should know:

  • How to design and program in the object-oriented (OO) paradigm making proper use of encapsulation, inheritance, and polymorphism.
  • The Unified Modeling Language (UML) diagrams, industry standard to describe program designs.
  • The Java programming language to implement OO program design.
  • Common design patterns, such as composite, command, singleton, strategy, state, visitor, adapter, decorator, factory, facade, null object, template, and iterator.
  • The formulation and implementation of basic data structures, such as lists, stacks, queues, trees, and tables.
  • Fundamental algorithms on data structures, such as searching, sorting, hashing, and structural traversal.
  • Graphical User Interface (GUI) programming using Java GUI components and the Model-View-Controller (MVC) paradigm.
  • The basics of component software construction and object-oriented frameworks.
  • Rudiments of complexity analysis, such as asymptotic behavior and "big O" notation.
    
    

  COURSE SCHEDULE:

  There are basically 15 weeks of classes. We intend to present the following topics in the following order. The time allocated to each topic is only approximate.  We may also change the order of presentation of the topics should we find it necessary to do so.

  Weeks 1-4: Transition from functional to object-oriented programming: primitive types, String type, classes, fields, methods, constructors, UML diagrams, abstract classes, interfaces, inheritance, polymorphism, immutable linear recursive structure and the composite pattern, static fields, static methods, the singleton pattern, the visitor pattern, tail recursion, exception handling, framework, abstract factory, component software.

  Weeks 5-6 : Mutable linear recursive structure and the state pattern; Graphical User Interface and event-driven programming, strategy pattern, command pattern, the Model-View-Controller (MVC) paradigm; inner classes.

  Weeks 7-12:   Object-oriented formulations and implementations of common data structures such as stacks, queues, binary trees, binary search trees, self-balancing trees; adapter pattern, decorator pattern, iterator pattern; priority queues as restricted access containers.

  Weeks 13-15: Game trees, min-max principle, alpha-beta pruning; Arrays, searching, hashing,  Meritt's sort taxonomy and the template pattern, simple sorting algorithms, quick sort, merge sort, heap sort, complexity analysis, 

  The above schedule should be viewed as tentative only.  We will vary the pace of the class and change the presentation order of the topics according to how fast the class is absorbing the materials as a whole. If we work hard together, we will cover everything. Please feel free to fit to give us feedback on how the class is coming along. Your input is very important to the success of this class.  We want you to all succeed and we need your help.

  GRADING:

  The course grade will be based on:

  • Weekly homework assignments (50% total)
  • 3 exams (16%, 16%, 17%)

  Assignments’ due dates and rules will be clearly stated at the time they are given. No make-up exams will be given unless there is a legitimate excuse such as proof of medical emergency.

  We reserve the right to make slight modifications of the above weighting.

  ADA:

  Any student with a documented disability needing academic adjustments or accommodations is requested to speak with us during the first two weeks of class. All discussions will remain confidential. Students with disabilities should also contact Disability Support Services in the Ley Student Center.