Phase1

     Phase2

     Phase3

• Patrick Tibbetts tibbs@ccs.neu.edu
• Ed Wong edwong@ccs.neu.edu
• Jackson Fong jackson@ccs.neu.edu

1. Allow users of the CD-Draw program to create traversals by pointing and clicking on nodes and edges in the UML class diagram.
2. Print traversal specifications of the computed subgraph.

• Printing out the calculated subgraph for the traversal in class dictionary syntax.
• Testing and correcting any bugs in the existing subgraph algorithm.
• Documenting all of the code in demjava.beh that deals with the subgraph algorithm.
• Adding "through" property to the allowable traversal specification syntax.
• Improving the speed of the existing subgraph algorithm.

1. • Establish a general USE CASE.
   • Document the code for Doug Orleans's existing subgraph algorithm.
   • Implement a basic version of the algorithm ourselves, using Binoy's class dictionary (evolve.cd). This basic version will only deal with basic FROM ... TO traversals and will only use certain construction classes from evolve.cd. (no alternation classes yet)
   • Use a printing visitor to print the specifications of the subgraph traversal in "class dictionary" form.
   • Continually update this web page, documenting our progress.
2. • Allow the program to automatically read in two input files (unless there are errors).
   • Send the program's output to a file, instead of the screen.
   • Implement BYPASSING in the algorithm.
   • Add alternation classes to the class dictionary.
   • Add the coordinates of each vertex to the class dictionary and input file, and print the coordinates after the name of each vertex in the output file.
   • Collaborate with the group doing the GUI part of visual-traverse.
   • Continually update this web page, documenting our progress.
3. • Allow the program to deal with multiple targets.
   • Allow the program to do TO-STOP traversals.
   • Add the cardinality of each edge to the input file, and print the cardinality after each edge in the output file.
   • Add terminal classes (UTerm) to the class dictionary and check for terminal classes in the traversal specification. (There should not be any terminal classes in the source list, the bypassing list, or the target list.)
   • Continue collaborating with the group doing the GUI part of visual-traverse.
   • Fix any existing bugs in the algorithm.
   • If time permits, try to implement THROUGH in the algorithm.
   • Continually update this web page, documenting our progress.

Phase 1:


• 2/17/97 - Met with Kedar and Binoy to discuss project specifications. Clarified certain design issues. We will be meeting with Professor Lieberherr later today to discuss a few details about the design process.
  
  
• 2/17/97 - Met with Professor Lieberherr. Determined the exact project requirements. (listed above)
  
  
• 2/21/97 - Met with Doug Orleans. Discussed the algorithm that computes subgraphs, and how we will incorporate the algorithm into our project.
  
  
• 2/22/97 - Worked on implementing a basic version of the subgraph algorithm, following Doug's design. Binoy told us that we actually need to use a hash table to keep track of the UIDs and their corresponding UEdge or UVertex object.
  
  
• 2/23/97 - Continued working on our basic version of the subgraph algorithm. Having some difficulties getting the hash table to work properly. E-mailed Doug and Binoy about the hash table problems. Waiting to hear any suggestions they may have.
  
  
• 2/24/97 - Met with Binoy to discuss our Hashtable problems. He gave us two possible solutions. We used one of his suggestions, and now the Hastable is working fine. So at this point, the forward traversal is working properly.
  
  Next we wrote the backward traversal. It was very similar to the forward traversal, so we didn't run into any problems. Now that we got the forward traversal and the backward traversal working, we added the code to check which vertices and edges got marked by both traversals. (these are the vertices and edges contained in the subgraph) So now the subgraph algorithm works for basic FROM...TO traversals.
  
  Now we are working on the printing visitor...
  
  We encountered one small problem at first - we needed to make sure that only the edges, vertices, and UIDs that are in the subgraph get printed.
  
  We corrected the bug - the printing visitor works fine now. The output that it produces matches the output that we are supposed to pass back to the visual-traverse GUI team.
  
  Finished documenting Doug's subgraph algorithm code.
  
  All that is left now for phase 1 is documenting the USE CASE and making sure that all of our code has been cleaned up. (remove print statements that were used for debugging purposes, make sure that our code is fully commented, etc...)
  
  
• 2/25/97 - We finished cleaning up our code. Now we just need to do the USE CASE.
  
  The USE CASE is now finished. This means that Phase 1 is now complete.

Phase 2:


• 2/28/97 - Met with Binoy to discuss BYPASSING, accepting multiple sources and targets, and including Alternation classes in our class dictionary. We decided that we're going to have to wait until Phase 3 to try to work with multiple sources and targets. We also talked to Doug Orleans about some file input/output issues.
  
  
• 3/1/97 - We modified the program so that it now reads in two input files (the class dictionary and the traversal specification). We were also able to write the program's output to a file called program.output.
  
  Now we are working on BYPASSING...
  
  We got BYPASSING to work correctly. Since we check the BYPASSING list in both directions, we avoided the bug that Doug Orleans discovered in demjava.beh - the problem he found was caused by only checking the BYPASSING list in the forward direction.
  
  Tomorrow we are going to work on adding the Alternation classes to our class dictionary.
  
  
• 3/2/97 - We added Alternation classes to our class dictionary and then spent the rest of the day getting the Alternation classes to work. Doug and Binoy both told us that we would have to implement certain checks to avoid infinite loops caused by traversing to an Inheritance edge followed by an Alternation edge (knowledge path). We didn't end up checking for this type of situation, but our program seems to work fine - we're going to meet with Doug tomorrow to see if there are any situations when our code wouldn't work.
  
  
• 3/3/97 - We met with Professor Lieberherr and then with Doug Orleans. It was determined that the way we implemented Alternation classes is fine since our algorithm will only be dealing with flattened class graphs. In turn there is no need to concern ourselves with knowledge paths.
  
  We changed the way that the program names the output file. As long as there is an input file and a traversal specification file with the same prefix, the user can just type "java Main prefix" at the command prompt to run the program, and the output file will be called prefix.output. For example, let's say the files that are going to be used as inputs are called graph1.input and graph1.trav. To run the program, the user can just type "java Main graph1", and the name of the output file will be graph1.output.
  
  We changed the program so that every vertex in the input file now has a set of coordinates associated with it. These coordinates get printed in the output file right after the name of the vertex.
  
  Now we're updating our behavior file's documentation...
  
  
• 3/4/97 - We finished updating the documentation for the behavior file. This means that Phase 2 is now complete.

Phase 3:


• 3/7/97 - We met with Binoy to discuss our goals for phase 3. We decided that we should be able to include multiple sources, multiple targets, cardinality, and checking for terminal classes in our algorithm. There is also a chance that we will try to implement THROUGH, but only if there is any time left after we finish the other goals. (We also have to leave ourselves some time to study for our finals.)
  
  
• 3/8/97 - We added cardinality to our class dictionary and our input files. We also changed the algorithm so that it will make sure that the source and the target listed in the traversal specification are not terminal classes. (If either the source or the target is a terminal class, an error message gets printed and the output of our program is an empty class dictionary.)
  
  
• 3/9/97 - We changed the class dictionary so that the target of a traversal can be a TO or a TO-STOP. A TO-STOP traversal ends as soon as it reaches the target, so cycles are not included in the subgraph (they are included in a TO traversal).
  
  Next, we changed the algorithm so that it allows a traversal to have multiple targets. At this point, we encountered a bug: if a TO-STOP traversal has more than one target, and one of the targets has a subpath to one of the other targets, the subpath should get marked but does not.
  
  In the afternoon we met with David Mann to discuss how our programs will interact. Because of time constraints/scheduling conflicts, the integration of the subgraph program with the GUI program will not be as thorough as we had originally anticipated. However, it is important to point out that the two programs work very well individually.
  
  We changed the printing visitor so that it only prints the UIDs of the vertices and edges that are in the subgraph - this is the format that Dave requested. It is important to point out that the list of UIDs in the output file does not have to be in any particular order, as long as all of the edges and vertices in the subgraph are included in the list.
  
  
• 3/10/97 - Professor Lieberherr said that the TO-STOP issue that we were asking about is actually not a bug. The edge in question that didn't get printed wasn't supposed to be printed, which means that our algorithm does work properly.
  
  We fixed our algorithm so that it checks the bypassing list for the presence of terminal classes. If any terminal classes are included in the bypassing list, they are not put into the bypassvect, an error message gets printed out, and the algorithm still gets executed.
  
  Now we are adding a TO-STOP regression test to the Demeter/Java regression suite, at the request of Professor Lieberherr.
  
  The TO-STOP regression test is done. Now we just need to document the code that we added in phase 3.
  
  
• 3/11/97 - There is not enough time remaining for us to implement through. We made sure to inform Professor Lieberherr of this. It is also important to point out that both Professor Lieberherr and Johan told us not to worry about implementing multiple sources.
  
  The documentation is finished. This means that Phase 3 is now complete.