Iteration 4

• Phase: Elaboration.
• Dates: Nov 6 - Dec. 1, 2004

Tasks to be Completed

+ Documentation

• A goal for this iteration is to be able to share documentation with external developers.
• Finish HTML documentation for existing classes, and publish it in the developers section of our web site.
• Finish architecture overview document, and publish it in the developers section.
• Create and publish a template for the source code for a generic disturbance module. This template will serve as an aid for developers writing plug-in modules.

+ Architecture

• Finish writing the code for the wind module. This task was started to provide insight into 1) the documentation needed by external developers, and 2) the core parts of the architecture that need further analysis & design (such as Ecoregions and Species).
• Design & document the interfaces for the architectural elements that are identified in completing the wind module. These include LandscapeRegions, Ecoregions, Species, and TextFileReader (names are subject to change).
• Continue working w/Barry DeZonia on integrating GeoSpatial Data Abstraction Library (GDAL) into L-II. GDAL is an open-source C++ library for working with raster data.

Assessment

+ Overview

Although notable progress was made during iteration 4, we fell short on some objectives because of unforeseen circumstances: limitations with software to generate documentation for our source code, challenges with combining C# generics and unmanaged code (i.e., code that uses memory pointers; needed to use with GDAL), and Jimm's illness during the last week of the iteration.

+ Iteration 4 Hits and Misses

Miss NDoc is the top software tool for generating various forms of programmer documentation from source code for the .NET platform. However, the current version of NDoc does not support latest features of C# such as generics (due to license restrictions with current beta version of C# 2.0 compiler). Jimm began modifying NDoc's code (it's open source) during the planning of this iteration. He originally estimated a few days to update NDoc, but during the 1st week of the iteration, after examining the code in more details, he revised the estimate to 1 to 2 weeks. In lieu of this, we decided it was best to focus on the other forms of documentation: the architecture overview and the template for a generic disturbance module.

Hit Finished the first pass at the architecture overview document. It's now available in the Developers section.

Hit Finished 70-80% of the code for the wind module. This work helped determine how disturbance components will handle extra parameters for ecoregions and for species. Revised the existing interfaces to some of the core modules (e.g., landscape, raster I/O), and started the interfaces for others (e.g., logging, random number generation).

Hit Have been concurrently updating the description document for the wind module while working on the module's source code.

Miss Because the wind module's code hasn't been completed, the source-code template for a generic disturbance module hasn't been started.

Miss The interface to raster I/O module uses C# generics. Using GDAL requires the use of memory pointers. Discovered that combining C# generics with memory pointers is challenging because memory pointers must be used in code blocks that are flagged as "unmanaged" (i.e., the system's memory management is disabled). This design problem stretched the limited C# knowledge of Jimm and Barry, who are both new to C#.

Hit/Miss Jimm and Barry devised a brute force approach to combine C# generics and memory pointers in order to implement the raster I/O interface with GDAL. Barry has got an initial implementation of this approach running. Although it works, it's damn ugly in that there are over half a dozen copies of functions with very similiar code: the very situation which generics were designed to address.

Hit Just developed a better design to utilize C# generics and memory pointers more efficiently, to remove the loads of redundant code in the brute force method.

+ Iteration 4 Lessons Learned

C# generics are a powerful feature, but they differ from C++ templates in a number of ways. These differences mean it's going to take some time to become as proficient at designing with them as we currently are with C++ templates.

With the architecture overview document now available, the only remaining artifacts for the Elaboration phase are the Use Cases. If we can make substantial progress on them in the near term, we can move into the 3rd phase of the Unified Process: the Construction Phase.