CSC 308 Milestones 7 and 8
Revised 6 March

Milestone 7: 11:59PM Wednesday 4 March
Milestone 8: 11:59PM Wednesday 11 March

three prototype Java GUI windows for each team member
• updated work breakdown, with entries in a new "Prototype Files" column
• updated model, with Spest checking
• inspection testing, last round
• NOTE: Due to delayed feedback on Milesone 6, the updated requirements scenarios are not due until Milestone 10.

Activities

Milestones 7 and 8 involve continuation of the requirements and specification work begun in earlier milestones. Also, you will begin work on the Java GUI prototype. Specific tasks are the following:

1. Refine and expand requirements scenarios per team meeting discussions and written evaluation comments.

2. Perform the next two rounds of inspection testing by the assigned team members.

3. Begin work on the GUI prototype, as discussed in Lecture Notes Week 8 and the Milestone 8 prototype example.

   1. For Milestone 8 (NOT 7), each team member must produce at least three prototype GUIs.

   2. At least one team member must be responsible for the top-level prototype UI, including menubar (or equivalent) setup and a main method in a java file named "Main.java". (The menubar or other top-level UI counts towards one of the three-per-person GUI requirement.)

   3. There must be a UNIX Makefile that compiles all of the prototype GUIs together.

   4. For sample Java code and a sample Makefile, see the prototype directory in the Milestone 8 example.

   5. Add a "Prototype Files" column to the administration/work- breakdown file. In that column, list the .java prototyping files produced by each team member.

4. Refine and expand the object/operation model and continue work on the formal specifications (see note for items d and e below).

5. Assign individual formal specification duties, in consultation with Fisher in project team meetings during week 9. Record these duty assignments in the work-breakdown file.

Details of item c

You can implement the prototype directly in code as in the Milestone 8 prototype examples. Or, you can use an interface builder that generates the code. If you do use an interface builder, you still need to understand the code that it produces, in case it is necessary to modify it for behaviors that the builder-generated code cannot produce.

All source files for the prototype go in the project prototype directory. Define package subdirectories as necessary, with .java files stored in their appropriate places in the package directory hierarchy. Following the model/view packaging organization discussed below in the "Details of model and view packaging". If you prototype in a language other than Java, organize the pacakaging of the prototype directory as appropriate for that language.

Include a README file in the prototype directory that explains how to compile and run the prototype.

And don't forget to add the "Prototype Files" column to administration/work-breakdown.html, and list in that column the names of the .java prototyping files for each team member.

Details of items d and e

For Milestone 8, you should focus on the requirements updates and prototyping tasks, refining the model insofar as it supports these two tasks. The formal evaluation of Milestone 8 will cover the requirements updates and prototyping. The formal evaluation of model refinements will be done for Milestone 10.

For the Milestone 10 deliverable, each team member must refine the pre- and postconditions from Milestone 6, per the milestone 6 evaluation comments. In addition, each team member must add pre- and postconditions for one or more additional methods, that is, methods in addition to the three from Milestone 6 for which pre- and postconditions were defined.

For Milestone 10, each team member is required to complete the fully formal specification (i.e., pre- and postconditions) for some reasonable-size portion of the project. The average work assignment in this area will be pre- and postconditions for approximately ten to fifteen operations. However, in some cases where operation specifications are complex, a team member may do pre- and postconditions for fewer operations.

Overall, the team is responsible for the pre- and postconditions assigned specifically to the members, which will most typically mean that not all operations will have pre- and postconditions. As noted under "Activities", we'll discuss this in Week 9 meetings. See also the Milestone 8 example for the scope of work for Milestone 8.

In adding a GUI prototype, we need to consider refinements to the overall packaging of "model/view" design. Applying the "model/view" terminology to what we're doing in 308:

• the Java files in the specification directory are the "model"
• the Java files in the prototype directory are the "view"

A model/view design can be embodied in the Java packaging hierarchy to provide a good organizational framework. Specifically:

• under the specification directory, there is a model sub- directory that in turn has the model sub-sub-packages
• under the prototype directory, there is a view sub-directory that in turn has the model sub-sub-packages
• the sub-packages under model and view have same names, so that the model and view are logically paired.

This form is of model/view design is discussed in Lecture Notes week 8. The `Milestone 8 example provides an illustration of model/view organization for the Calendar Tool.