Contribution Information

- We started the process by reviewing each part together and deducing
  the Observer pattern in each
- We then went away to come up with preliminary designs for two each
  and gave those to each other for review
  - Chris took 1 and 3
  - Matt took 2 and 4
- Before Chris departed for an extended weekend trip he provided some
  starting points
  - rudimentary designs and UML documents for 1 and 3
  - basic, but working, code for 3 with the following classes:
    - ListExerciser
    - ObservingFunctor
    - IntegerList
- During the week, Matt wrote and revised designs for 2 and 4
- When we met again we pair-coded 3, switching back and forth quite
  frequently, Matt driving for most of the abstracting work.
  - Abstracted out the Subject and Observer interfaces
  - Raised the common Subject methods from IntegerList into
    BasicSubject
  - Raised the common Observer methods from ObservingFunctor to
    BasicObserver
  - Settled on using Iterators whenever looping over the Vectors so
    they could be replaced with something else
  - Created several Report? functors
  - Cleaned up messiness
  - Pair-programming proved quite effective as we caught errors as the
    other input and discerned patterns that the other was too
    close to see.
- Since that meeting
  - We both refined our design docs, incorporating comments from the
    other
  - Chris integrated the separate design docs into one doc with a
    common format
  - Chris started some javadoc on the code
  - Matt proofed the design docs
  - Matt improved the javadoc
  - Matt created a UML class diagram for #4
- Final stuff 
  - Both organized the huge pile of docs and source into a coherent
    collection
  - Chris printed everything up
- Evaluative stuff
  - Chris says of Matt
    - Matt's greater facility with java syntax helped me to articulate
      some of my ideas more clearly and clarified some of the
      concepts. Matt's always been a wiz at abstraction and that
      was especially helpful in the process of making the code more
      flexible. We have experience working together, so that made it
      easier to share tasks and distribute the load in what
      seemed to be a fairly even way.
      - Understanding of Java
        - excellent, although we both are a bit rusty on some of the
          security implications in inheritance, we were able to
          work through it quickly 
      - Understanding of the Observer pattern
        - Complete. Had it quick. No confusion.
      - Ability to work in a group
        - In this particular group, went well. We have a shared
          language and toolset from previous experience.
  - Chris says of Chris
    - Because I had a 5 day weekend away, I was rushed to get started
      and I think that helped to get the ball rolling early. The sample
      part 3 code, built on templates from Poseidon designs helped
      form a solid foundation from which we were both able to build
      and refine the later work.
  - Matt says of Chris
    - Chris had fresher knowledge of Java than I, which in
      several cases contributed to a quicker succession of ideas
      for refinement or correction of code.  Chris is a superb
      writer in general, and I believe that lent extra clarity to
      both our code and documentation.  Since we have worked
      together before, we were able to get up to speed quickly
      and divide labor fairly with a high level of trust and
      confidence.
    - Chris's early use of Poseidon helped him get a working
      prototype for #3 finished quickly, and the diagram lent
      clarity to my understanding of the code.  Because of his use
      of Poseidon, I gave the tool greater consideration and was
      able to take advantage of it to clarify #4.
      - Understanding of Java
        - As Chris says, we were both weak on particular details
          of security (i.e. public, private, protected, package) but
          were able to relearn the details quickly and empirically.
          Otherwise, no complaints.
      - Understanding of the Observer pattern
        - Complete and immediate.  This lent speed to our work
          together.
      - Ability to work in a group
        - No complaints.  We worked quickly and effectively as a
          pair.
  - Matt says of Matt
    - I understood the Observer pattern immediately and found it
      easy and obvious to apply to all 4 of the problems right after
      class. I brought a laptop loaded with Poseidon, J2SE 1.4, our
      design documents and ant to our programming session.  As a result,
      we were able to quickly code #3 as a pair.