Lab Exercise: Project Planning

This exercise is intended for you to start designing your project without worrying about how it will be implemented. Thus, without implementing any functionality, determine a set of objects and abstractions you think represent elements in the problem and can work together to implement a solution.

Submission

Show your progress to a UTA during lab when you think you are finished to get immediate feedback and then push the initial version of your design to your shared team repository.

As a team, complete the following activities:

• Review multiple Cellular Automata and think about useful abstractions by considering their commonalities and variations
• Discuss your understanding of the Interface Separation Principle and how it might apply to this project or how it might have applied to the OOLALA project
• Use CRC cards to find a set of classes to represent your design, focusing on the behavior and interactions between classes than their implementation
• Use Use Cases to verify the completeness and flexibility of your design, by writing "example code", a sequence of method calls from those on your CRC cards

Discussion

Each person should examine one of the following Cellular Automata and describe it to the rest of the team, then discuss collectively what might be common and what might vary across a typical simulation:

• Conway's Game of Life
• Spreading of Fire
• Schelling's model of segregation
• Wa-Tor World model of predator-prey relationships

Consider the following questions as you discuss the basic design elements of the Simulation project. Write a high-level description of the different parts of the project and how they can interact without worrying about any implementation details.

• How does a Cell know what rules to apply for its simulation?
• How does a Cell know about its neighbors?
• How can a Cell update itself without affecting its neighbors update?
• What behaviors does the Grid itself have?
• How can a Grid update all the Cells it contains?
• How is configuration information used to set up a simulation?
• How is the GUI updated after all the cells have been updated?

Before deciding on any specific classes or implementations, explore trade-offs between several designs and summarize your conclusions. Importantly, envision at least two different implementations (of data structures and file formats) and make sure your design does not reveal the specifics of either one.

Now that your team has thought about the problem generally, refine your discussion into a Object-Oriented design by identifying specific abstractions and their behaviors instead of implementation issues. A picture may be helpful to show how your parts are related to and dependent on each other.

• Use CRC cards for each class you want to describe in more detail.
  Write your version using full method signatures to provide more details about the required information.
• Use these Use Cases to help test the completeness and flexibility of your design.
  Write your version as a sequence of Java method calls to provide more details about the flow of information.
  • Apply the rules to a cell: set the next state of a cell to dead by counting its number of neighbors using the Game of Life rules for a cell in the middle (i.e., with all of its neighbors)
  • Move to the next generation: update all cells in a simulation from their current state to their next state
  • Switch simulations: load a new simulation from a data file, replacing the current running simulation with the newly loaded one

To make things more interesting, pair up with another team and try to implement the Use Cases using each other's CRC Cards!