Hierarchy-Based Technique

TERMINOLOGY:

• "Application" refers to the program you are building.
• "Original object model" is the object model of your application. We need not assume this object model was created with ET++ in mind.
• "Original dynamic model" is the dynamic model of your application. We need not assume this object model was created with ET++ in mind.

DESCRIPTION:

1. Given ET++, study the class hierarchy.
   INPUTS: ET++ hierarchy, ET++ architectural description
   OUTPUT: List of high-level, abstract classes containing useful functionality.
1. Identify which portions of the ET++ architecture (basic building blocks, application classes, graphical building blocks, system interface layer) contain functionality that will need to be used or modified for your application.
2. Using your assessment of step a, identify abstract classes that can be used in the new application.
2. Identify classes related to the problem.
   INPUTS: List of abstract classes, original object model
   OUTPUT: List of ET++ classes to be used in application
1. For each class in your original object model, find the appropriate ET++ class to subclass it from. Use the hierarchy browser to help you understand how attributes and operations are inherited. Use the code viewer to examine the details of classes. Document your work as you proceed.
1. For each abstract class you identified in 1b, examine its attributes, operations, and relations to other classes.
2. If the abstract class is a good match to classes in your original object model, this class can be used to subclass classes in your application. Record this class in your documentation and explain which of its attributes and operations are relevant to your application. Examine its children for an even closer match. Continue examining its siblings, or return to the parent class if there are no more siblings to examine.
3. If the current class contains functionality which is too specific and cannot be adapted for your application, do not consider it any longer. Record this class in your documentation and explain (either in terms of functionality or attributes/operations) why it was rejected.
2. If you cannot find an ET++ class that provides all of the operations required by a class from your object model, it is possible that your class will have to be formed as an aggregation of two or more ET++ classes. Find ET++ classes that cover subsets of the operations you need and begin thinking of ways to combine these classes.
3. Modify your original object model for the application, using classes from ET++.
   INPUTS: List of ET++ classes, original object model
   OUTPUT: Modified object model
1. Update your original object model to show which of your classes will be subclassed from ET++ classes (as identified in step 2a) and which will be composed of aggregates of ET++ classes (as identified in step 2b). Make sure that all relevant attributes and operations (as provided by ET++) are included.
2. If you have identified relevant classes in the ET++ class library which were not a part of the original object model, update the original model to include these classes and any appropriate links.
3. Check that the modified object model corresponds to the model of interaction provided by ET++.
4. This modified object model must be turned in.
4. Based on the modified models constructed in step 3, develop the system, exploiting the classes offered by ET++.
   INPUTS: Modified object model
   OUTPUT: Implementation of application
1. Develop the application, subclassing and aggregating where possible to make use of the attributes and operations offered by ET++ classes.
2. Write the code necessary to extend the functionality to the specific application, adding your own classes as needed.

The following must be turned in: 1. List of classes examined and rejected, with rationales. 2. Modified object model, showing classes provided by ET++ with their relevant attributes and operations.

Web Accessibility