CSCI 290 Course Schedule and Homework

WEEK 1: 8/27 - 8/31

Lecture 1: Overview of the course; reminder of why OOSE is good: data-hiding, encapsulation, modularity, inheritance. Reminder that children lack access to parent private data - protected/friends circumvent data-hiding. Comparison with non-OO languages.
Lecture 2: Sketch of semester project idea: "general graph browser". General notion of a graph and digraph, UML/OO Design as graphs, thesauri, Erdös graph, six degrees of separation, many other examples

WEEK 2: 9/3 - 9/7

Last day to drop without a "W": Friday, September 7th

Lecture 3: TEMPLATE METHOD design pattern. Virtual functions. Looking for generalities, unifying code in parent classes when possible, and using polymorphism to handle (minimal set of) behavior variance. Illustrated with different beverages in our Starbucks application framework.
Lecture 4: FACTORY METHOD design pattern. Beverages create the containers they need. Also classes can create themselves for various purposes. Details: scoping operator for calling parent function from child, syntax for calling parent constructor from child constructor)

WEEK 3: 9/10 - 9/14

Lecture 5: ABSTRACT FACTORY design pattern. When beverages need to create several objects of different types, bundle this functionality into an abstract factory, with child factories corresponding to each specific kind of beverage. Give example of a GUI, GUI factory, with children corresponding to different widget families.
Lecture 6: More on semester project. Introduction to semantic web, RDF, knowledge representation. RDF as a ``universal digraph''. Brief background on XML, serialization of objects, data exchange. Well-formed vs. DTD compliance.

WEEK 4: 9/17 - 9/21

Lecture 7: More on RDF. Syntax of RDF-XML, reification, meta-meta-data.
Lecture 8: STRATEGY design pattern. Extensibility is a problem with our current coffeehouse software, as we add new drinks we break alot of our generic code. Complicated hierarchies of beverages depending on a given virtual function (like make_me) are possible, but addition behavior variance means you either multiply classes or use multiple inheritance. One solution is to abstract out each virtual function into a separate inheritance tree and reimplement as needed for the children. Then each type in the original hierarchy can create the strategy it needs. Strategies are also useful for when you might want behavior to vary at run-time, like switching out a sort algorithm based on some prior knowledge of the structure of the data.

WEEK 5: 9/24 - 9/28

Lecture 9: Finish implementation of beverage's "make_me_strategy" hierarchy. Homework for next Tuesday is to code this up, and to add a second strategy to beverage for taking orders (e.g. alcoholic vs. non-alcoholic beverages). Also read the "qsort" man page. Discussion of template method vs. strategy, sorting as a template method, and then as a strategy (quick vs. bubble sort, etc.). Introduction to functional programming.
Lecture 10: Function pointers, GUI callbacks, and library design. Tree traversals with callbacks. "Functors" in C++.

WEEK 6: 10/1 - 10/5

Lecture 11: Lab: remediation (linked lists).
Lecture 12: DECORATOR design pattern. Condiments implemented this way, with decorator classes inheriting from beverage also. Homework for next Thursday is to generalize the cash register from homework one to allow condiments, compute the price and print a receipt correctly, allowing arbitrary condiments.

WEEK 7: 10/8 - 10/12

Lecture 13: Lab day: implement a "rdf_triple" class and a "uri" class.
Lecture 14: ADAPTER design pattern. Review for midterm.

WEEK 8: 10/15 - 10/19

The midterm exam is Tuesday, October 16th

Lecture 15: Midterm
Lecture 16: Class cancelled.

WEEK 9: 10/22 - 10/26

No class Tuesday October 23rd (Fall Break)

Lecture 17: Graph data structures. Adjacency lists vs. adjacency matrices. Refinements needed for our particular situation of RDF graphs (directed graphs with URI labels on edges and vertices).
Lecture 18: Detailed discussion of depth-first and breadth-first traversals of graphs; emphasis on notion that these traversals represent template methods. More on function pointers and functional programming.

WEEK 10: 10/29 - 11/2

Lecture 19: Lab day, supervised by Dr. Letscher.
Lecture 20: Continue implementation of graphs in class, supervised by me. Homework is to create a graph class that can read in a simplified version of the graphviz file format, and which can do depth-first and breadth-first traversals.

WEEK 11: 11/5 - 11/9

Lecture 21: Function pointer implementation of graph traversal. Other similar interfaces that arise in nature, e.g. interfaces to parsing libraries, XPath, and the like.

WEEK 12: 11/12 - 11/16

Lecture 22: Lab day, graph classes due on Thursday.
Lecture 23: Graph-drawing via Coulomb's law.

WEEK 13: 11/19 - 11/23

No class Thursday November 22nd (Thanksgiving)

Lecture 24: Dijkstra's algorithm and Floyd's algorithm. Applications to graph drawing.
Lecture 25: Lab day.

WEEK 14: 11/26 - 11/30

Lecture 26: Introduction to the WordNet RDF files. Parsing and grammars. LL parsing in particular.
Lecture 27: More on parsing, balanced parentheses language, deducing a grammar and proving it is correct. Shift-reduce parsing.

WEEK 15: 12/3 - 12/7

Thursday, December 6th is the last day of class
The final is Tuesday, December 18th, 8:00-9:50AM

Lecture 28: Class cancelled.
Lecture 29: TBA