Hotspots: Admin Pages | Turn-in Site |
Current Links: Cases Final Project Summer 2007
Team SmallTalkers Cases
SmallTalkers
M4 - Domain Design
For milestone 4, we had to meet with our group and decide whether to do the SmallGraph project or the alternative design contest. For the SmallGraph project, we went through the design process: Brainstoming, Filtering, CRC Cards, and Scenarios.
Requirements:
- Make a team page and indicate your team members and which option you are pursuing.
- A brainstormed list of Domain classes
- A list of candidate classes after filtering
- A set of CRC cards for the candidate classes. Cards should be filled out on both sides (role stereotypes and responsibilties/purpose).
- A set of scenarios that cover typical uses of system and exercise the CRC Cards.
- Meet with assigned TA after submission to discuss your design
What Worked
- We chose the SmallGraph project.
- We made our list of candidate classes and then filtered them.
- Instead of going straight to making CRC cards from the filtered list, we sketched out our design on the list with the dependencies.
What Didn't Work
- Starting with this milestone, we planned on doing several of the extra credit options such as undo/redo functionality, different shaped nodes, and different colors. Later on, we spent time working on this functionality instead of the requirements (for example, algorithms producing correct results).
Examples:
Scenario 1
A user is creating a new graph. When the user opens "Smallgraph" there is a blank canvas waiting for the user. They start adding nodes and edges from the window pane on the left. The properties of the node and edges are editable once each one is selected and the properties are shown on the left in the window pane. Once all the nodes and edges are added, the user runs various algorithms on the graphs and saves the results from the file menu. The file is saved as an XML.
Scenario 2
A DoT Engineer is planning construction project and is closing a couple roads. He is going to use the SmallGraph program to determine the best way to re-direct traffic. He goes to File>Load and loads a map of the portion of the city that he is working on. He loads his own algorithm from the Algorithm menu. He selects the starting point and ending point of the detour and these "nodes" change shape. He runs the algorithm by pushing the run algorithm button. A window opens to indicate that the algorithm is processing. Once the algorithm is complete and the results are available, the detour path is indicated by a dashed path, whereas other paths are indicated by solid paths.
M5 - Application Design
For milestone 5, we continued the design by creating UML diagrams and changing our initial design where necessary.
Requirements:
- Create your Software Architecture and Trust Boundaries
- Identify your Application and Utility Objects
- Add necessary CRC Cards and any new scenarios needed
- Submit a UML Class diagram of your refined design
- Submit 2 UML Sequence diagrams that shows your full design handling one or more scenarios
- Submit screen mockups that show your preliminary user interface. These screens can either be hand-drawn, or prototyped with the VW Painter and then captured.
What Worked
- Because we already had a good domain design, it was easy to split up the workload for the UML diagrams and screen mock-ups.
- Using software designed specifically for creating UML diagrams made this step much easier. While we were creating them, we made many changes and were able to save much time.
What Didn't Work
- We started brainstorming application classes in the previous phase before we were finished with the domain design. Later on, we had to change/filter these classes to work with our domain.
- We were never clear about which architecture style to use and how to design our trust boundaries; however, this was not a huge issue since we all had an understanding of how the program should work.
Examples:
CRC Cards(pdf)
UML Class Diagram(pdf)
UML Sequence Diagram 1(pdf)
UML Sequence Diagram 2(pdf)
Software Architecture & Trust Boundaries(pdf)
M6 - Domain Coding
For milestone 6, we started coding the domain classes for our project.
Requirements:
- Implement Domain Objects
- Create SUnit tests to unit test your core Domain Objects
What Worked
- Since we made detailed CRC cards and UML diagrams, it was easy to split up the work for this milestone. We then had to meet before submission to merge all of our code.
What Didn't Work
- We procrastinated on this milestone. In retrospect, if we had started coding earlier the algorithms would have been more accurate and we would have had more time to work on extra credit parts of the project.
- We did not initially use a namespace, which made merging our code difficult.
- Also, due to a lack of time, the SUnit tests were lacking, so they weren't very useful later on.
M7 - GUI Coding
We began constructing the GUI for our project in this milestone.
Requirements:
- Graph Editing (add/remove nodes edges)
- Algorithm results displayed on screen
- Change display (drag around nodes, change layout)
- Graph display (shows graph on screen)
- SUnit tests (for any non-gui classes added)
- Good Smalltalk code and style
What Worked
- Once we had the GUI drawn with the canvas tool we were able to bring all the components together into a fairly functional program.
What Didn't Work
- For this milestone, we had difficulty distributing the work. We mostly worked together crowded around a single computer.
M8 - UI Evaluation
We exchanged projects with another group and performed an UI evaluation.
Requirements:
- Plan your usability evaluation
- Execute the plan
- Usability Report
- Rebuttal
What Worked
- We used a spreadsheet to perform our cognitive walk through. We made a row for each function of their program. We made columns for each step involved in executing the operation, the intended goal, whether action is obvious, whether the action matches the label/goal, and the feedback provided by the application.
M9 - The Twist
The Twist involved making a web page interface for our application.
Requirements:
- Graph can be created
- Nodes can be created
- Edges can be created
- Algorithm results displayed for:
- BFS (List of nodes)
- Max Flow (Just the number)
- Shortest Path (List of edges)
- Connectivity (true/false)
- Spanning Tree (List of edges)
What Worked
- Because we had a good design, we were easily able to adapt our application to a web interface without changing much in the domain.
Link to this Page
- Cases last edited on 30 July 2011 at 2:33 am by r59h132.res.gatech.edu