Informal Science Education II
High Level Design
EEL 5881 - Software Engineering I - Fall 2000
Modification history:
| Version | Date | Who | Comment |
| Version 0.0 | August 15,
2000 | G.H. Walton | Template |
| Version 1.0 | November 4, 2000 | Michael Wales |
Initial Document |
Miles Computer Engineering
Team Members:
Contents of this Document
High-Level Architecture
Design Issues
High-level Architecture:
- CAPane: This class is instantiated by the CASim class and it
contains the content pane for CASim.
- CASim: This is the main class of the program. It will
instantiate the TransitionWindow class when the user selects
that they need to edit the simulation's transition and state
properties. The design of this part of the program is still very
primitive, and we expect it to expand a great deal.
- LoadTransitions: This class is instantiated when the user
selects to load a set of transitions from file in the transition
editting window. The TWButtonListener will instantiate the
class and execute it's methods.
- NewStateWindow: This class is instantiated by the
TWButtonListener class when the user selects that they would like
to create a new state. This class will then prompt the user for the
state's information like it's name and file for the picture to
represent the state.
- TransitionA, TransitionB, TransitionC, TransitionD, and
TransitionE: Classes created by the TransitionWindow class.
These classes contain the GUI components used by the
TransitionWindow class. Each of these classes also contains the
code that will detect if the current cell will transition to a
different state. This is the class that a user will modify if they
wish to create a more complex transition algorithm.
- TransitionWindow: The class will be called by main editing
window, and only can be called once. It will need to be passed the
state information and transition information for the current simulation.
This class will have interfaces for initializing the GUI, showing the
GUI, and exiting the editting window.
- TWButtonListener: This class will be instantiated when the
GUI for the TransitionWindow is created. It will need to be
passeed TransitionWindow class because it will need to access
most of the GUI components belonging to that class. This class's
purpose is to handle all the button events of the TransitionWindow
class. All the menu bar selections are treated as button events
also. The TWButtonListener class will also instantiate classes
for button actions such as creating a new state, deleting an old state,
saving the current transitions, and loading an old set of transitions.
- SaveTransitions: This class is responsible for saving the
transition and state information in a file. It will be instantiated
by the TWButtonListener class when the user chooses to save
the transitions in the transition editting window.
- StateList: This is the class that will hold the information
about each state. It will hold the text name for each state, the image
that the state is represented by on the simulation window, and the
filename that the image can be located at. This class will be used by
the classes performing the simulation and the TransitionWindow
class.
Design Issues:
Most of our focus in designing the code for this project will be on
maintainability. Since it is the biggest part of the life cycle and can
be the most difficult aspect of the project. We are going to focus on
well documented code and well designed modules. We would like to avoid
high coupling between our modules, but that is becoming a big challenge.
I think the final product will have sets of classes that are highly
coupled together, and there will be low coupling between the different
sets of classes.
Another thing we considered when we started the project was it's
portability. It was clear that would be creating a graphical program, so
using C++ would cause the program to be only supported on the platform
that the graphics library was for. Java was an easy choice because of it's
portability, similarity to C++ (we have studied C++ mainly in computer
engineering so far), and it's ease of use. This program can be run on any
computer that is supported by the JRE (which includes PC, Macintosh, Sun,
SGI, and even some PDA devices). The biggest downside from using Java is
that the performance will be less than anything that is in native code.
Performance is extemely poor on a 486DX-120 with our program, but if it was
in native code we probably wouldn't even notice. Fortunately, most of the
computers today that are still in use are many generations ahead of the
486 and the performance issue won't be as noticable.
Our biggest technical issue involved in this project will be trying to
learn the Java GUI components. For Jeff and I, this is our first large
programming assignment, and our first programming assignment involving
a GUI interface. It's also been difficult to design the project because
we are not familiar with the Java GUI components and how to interact with
them.
Template created by G. Walton ( GWalton@mail.ucf.edu ) on October
8, 1999 and last modified on August 15, 2000
This page last modified by Michael Wales ( Mag7Rule@aol.com ) on November 6, 2000