NKU CSC 601 Advanced Programming Workshop Fall 2002 - Kevin Kirby Materials will be added here as the course proceeds.

SYNOPSIS OF MEETINGS

Week 1 - Tuesday - August 20

• Introduction and course overview.
• Review of exception handling in C++, including anonymous construction, <stdexcept>, and bad_alloc.
• Assigned readings for this week: Stroustrup Chapters 10,12,14.

Week 1 - Thursday - August 22

• References revisited
• From procedural to ADT programming.
• ADT topics: 
  • public/private, static/nonstatic, const/nonconst, logical/physical const, mutable
  • aggregation/composition, private inheritance 
  • invariants
  • PImpl idiom
  • inlining
• Other influences: 
  • event-driven programming
  • concurrent programming (threads & processes)
• The OO paradigm: polymorphism
• Pure abstraction: interfaces

Week 2 - Tuesday - August 27

• Interlude: The Partition ADT and the amazing pseudo-inverse of Ackermann's function
• Illustrations of last week's OO review in one code example: QueueDemo.cpp
• Assigned readings for this week: Stroustrup Chapter 25

Week 2 - Thursday - August 29

• Adding an iterator to an interface: requires (abstract) factory method and use of auto_ptr
• Example developed in class: QueueDemo2.cpp

Week 3 - Tuesday - September 3

• Specialized return types from function overrides (e.g. abstract/concrete iterators)
• Dynamic casting
• Getting started in Scheme (see online book!)

Week 3 - Thursday - September 5  [shortened class period]

• List processing in Scheme
• Internal representations of lists
• Lists vs. pairs

Week 4 - Tuesday - September 10

• Value and reference equality predicates in Scheme
• Side effects: begin, display
• Scheme idioms
  • Implicit iteration (with map)
  • Linear recursion ("cdr-ing down a list")

Week 4 - Thursday - September 12

• More Scheme idioms
  • Tree recursion
  • Functionals

Week 5 - Tuesday - September 17

• Practice with Scheme
  • Warmup exercises
  • The matches? predicate (see matches.scm) 

Week 5 - Thursday - September 19

• Scheme & syntactic sugar using procedures (see dtrans.scm)
• C++ Proc - ADT - OO Benchmarks:  Discussion of class results 
  • cost of dynamic allocation for path compression
  • VC++6 inlining bug

Week 6 - Tuesday - September 24

• Two functional programming topics
  • Recursion in ttrans generating non-recursive code in the tlambda-defined function
  • Scoping, quoting, and evaluating: getting friendly type-mismatch messages in ttrans 
    

  PLT Scheme Note If you would like to use "trace" with your code:      (require (lib "trace.ss")) You can enable tracing this way: (trace your-function) ; now each call/return to/from your-function will print a line of output in a box When you are done, you can turn it off: (untrace your-function). You can put traces on many functions at once.

Week 6 - Thursday - September 26

• C++ Template review/overview
  • Template classes 
  • Template functions
  • Template parameters:  
    • typename / class  (most common)
    • simple types: e.g. int  (less common)
    • templates (esoterica)
  • Examples: Templatorama.cpp 

Week 7 - Tuesday - October 1

• Typedefs for element types in class templates for containers
• Reconsidering exception specifications in generic programming
• Abstraction via templates and via inheritance: a min with "IComparable" vs. "TComparable"
• Generic programming strengths over OO:
  • Higher (runtime) efficiency.
  • Broader range of types captured (e.g. does not require a class implementing a certain interface).
  • No dynamic binding overhead; no RTTI downcasting overhead: type mismatches caught at compile-time.
• OO strengths over generic programming:
  • A clear contract exists for specifying a type.
  • It is difficult for compilers to produce reasonable diagnostics through layers of template instantiations.
  • Code with templates can grow large.
• The standard approach: generic for small & fast support pieces; OO for the big picture. (But lots of middle ground!)
• The centrality of operator overloading in generic programming. 

Week 7 - Thursday - October 3

• Template metaprogramming: sick factorial example
• Generic programming: see GenericMaxjump.cpp
  • using traits of sequence containers, e.g.: TCont::value_type
  • random-access vs. (merely) forward iterators
  • using traits of iterators (including T*), e.g. iterator_traits<It>::value_type
• Overloading prefix vs, postfix Xcrement operators 

Week 8 - Tuesday - October 8

• Overview and design philosophy of STL: pure abstraction / compile-time polymorphism
• Functors (functions, function objects); overloading operator()
• "Pointors"; overloading operator-> and operator* 

Week 8 - Thursday - October 10

• Review for midterm

Week 9 - Tuesday - October 15

• FALL BREAK

Week 9 - Thursday - October 17

• MIDTERM. Average: 58/75.

Week 10 - Tuesday - October 22

• Iterators for nonlinear containers.
• STL-friendly containers, and derivation from std::iterator classes.

Week 10 - Thursday - October 24

• STL function object base classes

Week 11 - Tuesday - October 29

• Binders

Week 11 - Thursday - October 31

• Function object + functional design pattern, for compose, ptr_fun, and bind3rd
• See Funcadelic.ppt 

Week 12 - Tuesday - November 5

• Pointer to members and mem_fun- type functionals in STL

Week 12 - Thursday - November 7

• Static assertions
• Concept checking and metaprogramming

Week 13 - Tuesday - November 12

• Typelists and metafunctions (Length and Includes)

Week 13 - Thursday - November 14

• Mechanisms for template metaprogramming vs. mechanisms for pure functional programming
• Turing universality and its consequences: uncomputability (part I) [see handout]

Week 14 - Tuesday - November 19

• Effective enumerability and the halting problem [see handout] 
• Parallel computing and message passing: applications

Week 14 - Thursday - November 21

• MPI

Week 15 - Tuesday - November 26

• Review 
• Anne & Panampully,  i18n

Week 15 - Tuesday - November 28

• Thanksgiving Break

Week 16 - Tuesday - December 3

• Davidson & Williamitis, Enterprise Java 
• Uppalapati & Shergill, Ruby

Week 16 - Thursday - December 5

• Keel & McCord, Web Services and SOAP
• Clark & Helmick,  gSOAP without XML

Week 17 - Tuesday - December 10  6:45 - 8:45 pm

• Makeup test (ST 255)

Week 14 - Thursday - December 12  6:45 - 8:45 pm

• Chen & Miller, .NET Garbage Collection Algorithms
• Morrison, Bioinformatics
• Gundling & Wang, Curl

Back to main CSC 601 page.

Last updated: November 22,  2002.