Log Book

24 Feb:
Researched some products in use by clients for distributed reporting. Documented main features in Wiki.

25 Feb:
Researched commercial and open source reporting packages. Noted main features. Read documentation and tutorials for open source libraries JFreeReport and JasperReports and noted comparisons.

26 Feb:
Explored source code of JFreeReport and JasperReports packages, noting design features that may make them more 'extendable' for GUI reporting. Meeting to discuss features of existing VB FlexiGrid and additional requirements for Java grid.

27 Feb:
Documented requirements. Drafted a rough project outline. Began working through Java Swing tutorial.

28 Feb:
Documented features of reporting tools in Wiki.

3-7 March:
Working through Java Swing tutorial and examples.

13 March:
Created PowerPoint slides for BTech project introductory seminar.

14 March:
Completed preparation of introductory seminar. Presented to Kiwiplan Java developers and managers. Began coding a simple application with sample data.

18 March:
Revising seminar content. Started project website.

19 March:
Introductory presentation.

21 March:
Added project outline to website. Experimenting with Swing tables and table models.

1 April:
Prepared project plan. Finished setting up project website.

3-4 April:
Requirements and Specification. Decided on a subset of the requirements for the first stage of development. Prepared a Use Case diagram and conceptual UML class diagram. Began documenting specifications as a "Software Requirements Document".

11 April:
Documented use case specifications. Prepared UML sequence diagram. Completed Software Requirements Document for stage 1 of the reporting system.

15-17 April:
Worked full-time at Kiwiplan. Prepared OO Design diagrams for stage 1 of the reporting system. Discussed design with Gareth at Kiwiplan. Started coding simple Java classes.

2 May:
Continued coding of stage 1. Have completed the 'bean'-like classes for queries, query results, report definitions, and object descriptors. I am adjusting the design slightly as I go - I'll need to update the OO Diagrams at a later stage.

9 May:
Started writing classes for mapping query results to TableModels. Wrote base classes for creating report filters. Implemented a simple filter which replaces the attribute names with friendly column titles. Wrote some JUnit test cases. Created a very simple demo app which displays a JTable with data from the reporting system. Currently some mappings are hard coded - these will be replaced with more flexible classes later.

16 May:
Working on 'client-side' code that allows the user to construct a report definition from the GUI. Demo app allows the user to select a business object and add/remove columns from the report.

22 May:
Updated project website. Began work on the semester report.

23 May:
Continued coding of stage 1. Demo app allows the user to select a Business Object type, add remove columns from the report, change the column order, and rename column headers. Met with department manager and Java developers and to discuss project design and how it fits with other work they are doing. Key issues raised are: consider pushing business objects all the way to the client, allow editing of data from the grid, windowing of data so that only the required data is transfered from the server (rather than the entire data set).

26 - 30 May:
Preparing semester report and presentation.

2 – 4 June:
Continued preparing semester report.

5 June:
End of Semester Presentation

6 June:
Completed End of Semester Report. Updated website.

1 - 18 July:
Worked at Kiwiplan fulltime during the inter-semester break, largely focussing on project work. Refactored my classes to merge with existing Kiwiplan code. Created simple test applications. Worked on filtering the rows of the report according to a user's criteria. Initially created a filter that filters according to a single cell value. Worked on Kiwiplan's criteria objects, adapting them to be able to be used with a table model, and directly on business objects. Created several criteria table model filters for AND, NOT, OR and value based criteria. Initial implementation was to create a separate filter for each part of the criteria, and combine them in the pipeline. Created a simpler criteria filter that can apply several ANDed or ORed criteria inside a single filter. Created a simple VPL for configuring criteria filters (uses a pipeline analogy - the user drops filters into the pipeline to apply criteria to their report). Wrote JUnit use case tests as I went. Created a simple implementation for persisting criteria (serialization + base64 encoding). Began work on XML representation. Finished by creating some new example data classes for another simple demo app.

30 July:
XML persistence of criteria requires polymorphism (the value of the criteria could be any of several object types). Decided to put this temporarily on hold and give further thought to the best method handling XML representation. Worked on the GUI for the criteria vpl - added a properties panel that allows the user to edit criteria values and types.

6 August:
Brought together the table model and criteria vpl to produce another demo. A table displays example data, the user can sort by clicking on the table headers. There is a button which opens the criteria vpl. The user edits the criteria and clicks ok. They are returned to the table, which now only displays those rows matching the given criteria. Wrote code to create a default report for a business object based on information in the application properties files.

13 August:
Refactoring of the classes performing relection on the business objects (so that reports can be loaded and saved independently of their data). A report can now have multiple 'filter workspaces' - a single report can have several criteria applied, these can be edited individually in the vpl (saves overcluttering the vpl gui if multiple criteria are to be applied). Began work on simple persistence of a report (serialization + base64 encoding). This will eventually be changed to an XML representation. Wrote unit tests for many of the filter methods and the persistence.

15 August:
Created screenshots of the current demo. Updated project website.

20 August:
Continued work on loading and saving of reports. Multiple versions of a report may be saved. When a user starts the demo application they are presented with the 'default' report for the object. They can make changes to the default report and save it, or they can save their report with a different view name.

27 August:
Planning for the addition of grouping. A sorting filter will be followed in the pipeline by one or more grouping filters. A grouping filter adds a header and footer row for each group. Later in the filter pipeline Reflection and Expression filters can be used to display group properties, and calculate group totals. May need to add some concept of 'dependencies' to the filters so that they are placed in the pipeline in the correct order.

2 - 5 September:
Worked on performance improvements for the Sorting filter. Currently, when groups of objects are drag and dropped onto a table it takes a long time to insert them (the table is being resorted for each insertion or removal). Made the handling of table model events more fine grained so that insertion or deletion of single rows, or multiple contiguous rows can be handled without resorting the entire table.
Debugging and testing of table features in preparation for a product demonstration.
Created a ColumnHiding filter, so that the table can be sorted according to a given column, and then that column hidden from the final display to the user.
Started work on Grouping filters.

10 September:
Completed grouping filter. Multiple levels of grouping by adding multiple filters to the pipeling. Added support for reflection on group properties. Worked on persistance of the report again, following changes to a number of classes.

17 September:
Refactoring of reflection filters - extracted superclass in preparation for an 'Expression' filter. Encountered CVS problems. Created an 'Expression' filter which evaluates Java code at runtime using the BeanShell package. Allows for the calculation of group totals, user-defined expressions, etc. Because code is interpreted at runtime there is a noticable performance hit - a caching filter will need to be used after any Expression filters to improve scrolling speed in the table. hit

20 September:
Began work on final report and presentation.

21 - 26 September:
As much as possible, I am trying to spend at least an hour each day working on the final report (in addition to my existing project time).

27 September:
Opted not to go into Kiwiplan today. Instead I continued work on my final report from home. Have completed an overall plan for the report and written draft outlines for several of the sections. Wrote discussion of the report processing sequence and explanations of some of the filters.

28 - 30 September:
Continued daily work on project report. Currently working on a detailed comparison of reporting from business objects versus a database backend.

1 October:
Improved user interface. Worked on Swing actions that allow the user to customise the report. Testing and debugging. Updated the demo application for use in the project presentation.

2 October:
Attended BTech meeting. Updated progress section of the website. Took screenshots of latest demo application.

3 - 7 October:
I'm now spending every free minute working on the final report. Stress level is high.

8 October:
Worked on final report from Kiwiplan offices. Created some UML diagrams. Changed filter workspace slightly to make things more visible for the project presentation. Ran some performance comparisons.

9 - 20 October:
Updated website. Continued work on final report.