CSE 111 - Object Oriented Software Design

Project:

The projects should be done in teams of 3-5 people. Your team will develop and implement a simple system with a GUI front end, a middle business logic layer, and a simple database (e.g. file system with a front end). The project will be done in 2 phases. The first will have limited functionality, and the second full functionality. The language of choice is Java. The modeling language is UML. UML diagrams can be drawn using MS Visio, which is available in the lab.

The lectures will use a (very) simple dating system as an example. You can use this as a guideline for the kind of functionality we are looking for in your system. Your team should come up with a project of similar difficulty and functionality. The point is to try out the basic methods and ideas that will be introduced, and not get bogged down in programming in the short amount of time available to us.

The following is a brief overview of the dating system example.

"There are two classes of users: member and administrator. A user starts the system and logs on, giving a name. The system determines the class of user by looking in a member database. If the user is there, then either a get a date or an update data option can be chosen. If the member is not there, a message is given, and the system returns to its initial state. If the user logs in with a special name, then the system goes into administrator mode, and the following options are given: add a member or delete a member. If a member is added, the member data in the DB will be empty until the user puts in the data."
"A member has properties on the basis of which a date can be selected. In this case they are: gender, religion, and occupation. These are the properties that are stored for a member, and the properties that a member uses to ask for a date. The system tries to find an exact match. When match is found, the email address for the datee is given, which is also stored in the data base."
"After some function, such as finding a date, the system returns to its initial state, from the which the user can start another session (which requires another logon) or terminate the session."

There will be two project deliverables, one for each phase (up to midterm, after midterm). The first will contain the deliverables described for each of the lectures up to the midterm, and will be due on the lecture after the midterm.

The second will contain the deliverables described in the lectures after the midterm. You should also redo the deliverables from the first phase for the added functionality of the second phase. It may be easiest to completely redo the first phase deliverables and hand this in instead of just adding the second phase functionality increment for the first phase deliverables.

Deliverables for Phase 1

Due date: lecture 12 (5/10/07)
  1. What to deliver:
    1. High-level overview and description of your project.
    2. All of the items described as tasks after each lecture, e.g. use cases, domain model, overall architecture description, sequence interaction diagrams, collaboration diagrams, discussion of cohesion and coupling properties of your design, discussion of use of patterns in your design, class diagram for design, and code.
    3. Descriptions of 3 use cases you implemented, and of the tests.
    4. Screen shots of the GUI displays for the 3 tests (combine multiple screens shots on one page to reduce space).
    5. Source code files and object code classes, stored with their source code files. Note that I will recompile the program.
    6. Your code should be designed so there is a top level class called Start that has the main() routine in it. In the "readme" (see below) indicate what command in the command line is needed. e.g.

      A:\> java -classpath A:\GiftingSystem Start

      You should also describe what command could be used to compile your source code files. As above, this should allow this to happen from the media you have handed in. Your code must be compilable and runnable from a command prompt window on Windows (or Linux), as in the lab, and must work for the JDK software that is installed there (or JDK 5).
    7. Readme:
      1. a brief description of how to use your system, including any special GUI features the users should know about
      2. a brief description of how the code is organized, such as package/file structures
      3. what command line needed to compile (and ANT script if necessary)
      4. what command line needed to run
  2. How to deliver:
    1. Hard copies of UML diagrams, tests, and readme. Please turn in class.
      1. make sure each page is clearly labeled
      2. put them in an 8x11 yellow manilla envelope
      3. write on envelope: "CSE111 Project Phase 1", with names of group members
    2. Electronic copies of everything (UML diagrams, tests, readme, code).  Group all files into one folder and compress the folder in either ZIP or TAR.GZ format. Then, email me the following:
      1. subject: "CSE111 Project Phase 1"
      2. include names of group members in the body of the email
      3. attach compressed files.
Note well:
  1. For the UI, you can use Swing or AWT, but not any drag-and-drop GUI builder tool. You have to wire it up yourself.
  2. You will get the most benefit from the project if you do the non-code documents as they are assigned, and then modify them later as your understanding develops.
  3. Interaction diagrams (i.e., sequence and collaboration diagrams): you should organize your sequence and collaboration diagrams by corresponding use cases.
  4. For phase 1 you will implement 3 or more use cases. If you implement more than 3, make sure you provide design artifacts (use case description, sequence & collaboration diagrams, etc) for all of them.
  5. Your sequence diagram should show how the layers interact. Both sequence and collaboration diagrams are tied to use cases. You will have at least 1 sequence diagram for each use case. In this project you will use collaboration diagrams to show the interactions within a layer. Since you have 3 layers, you will need at least 3 collaboration diagrams for each use case.

Deliverables for Phase 2

Date due: last lecture (6/7/07)

The deliverables are:

  • An updated version of all that was in phase 1. This mean correct and upgrade your domain models and other diagrams from the feedback you got, and then from there, extend/update the diagrams to add the new functionality you implemented for phase 2.
  • All the UML diagrams for the new functionality added since phase 1. If your new functionality was not fully documented in the first phase, make sure it is for the second phase.
  • New UML models:
    1. use is-a and has-a notation in the class diagrams
    2. state diagram model for GUI, in graphical or tabular format
    3. programming by contract specs for subsystems
  • Patterns
    1. for each pattern that you incorporated into your design, briefly describe how it was used. As per the lectures, the patterns to be used are: callback, singleton, wrapper, state (optional, but discuss why you did not use it if you did not incorporate this pattern), and framework/factory methods for data base.
    2. if you had additional patterns from the second part of the course, include a brief description of how you used them, but it is not necessary to use these patterns
    3. you do not need to include anything on anti-patterns or refactoring
You will need to implement fully all the use cases. Make sure you add every deliverables that is mentioned in the lecture page.