CS 110 Final Project

CS 110 Fundamentals of Computing
Final Project
Bolker and Rodriguez
Spring 2004

In this final project you get to use all the Java you have learned to design and build a modest application from scratch: a model for part of a university on line course management system, like the UMB WISE system.

A solution.

Here is a the source code for a WISE implementation, as individual files and as a single zip file for easy downloading. The subdirectory numbered contains line numbered versions of the .java files. There's a zip file for these too. The subdirectory tests has class files and testing scripts.

Due dates and deliverables.

At each delivery you should submit only commented code that compiles and runs and has been thoroughly tested, along with a memo.txt that describes your design decisions, what features are present and how you tested them.

Tuesday, May 4: turnin work to directory wise0
Tuesday, May 11: turnin work to directory wise1
Thursday, May 13: turnin work to directory wise

There is no precise specification for just what you should turn in at each stage. What's important is that you have almost half the work done by the 4^th and almost all of it done by the 11^th - your final grade for the project be based on evidence of serious progress along the way. That means you can't get a good grade even if you are able to do all the work in the last two days!

Partial solution.

Here is a partial solution to the WISE project - posted May 5, after the first deliverable. You may use it instead of what you have done yourself so far, read it for what you can learn from it, or ignore it if you are working in a different direction satisfactorily.

Updates

During the development process questions will be raised asking for clarification. Rather than edit this page, I will keep the answers to those questions on the updates page, in reverse chronological order. I will inform you be email each time I update that page.

User interface

To start the system you provide it with three text files on the Java command line, one each describing courses, students and professors. Here is a sample WISE session, made up to illustrate WISE input syntax. The exact specifications may change (slightly) as work progresses.

  > java WISE courses.txt students.txt professors.txt
  Welcome to Ethan Bolker's WISE implementation.
  WISE> type courses       # see list of courses
  WISE> type students      # see list of students
  WISE> type professors    # see list of professors
  WISE> assign courseName professorName 
  WISE> enroll studentName|ID courseName
  WISE> type courses courseName             # class list for this course
  WISE> type students studentName|ID        # schedule for this student
  WISE> type professors professorName       # schedule for this professor
  WISE> courses time                        # open courses at specified time
  WISE> professors time                     # professors free at specified time
  WISE> students studentName|ID time        # times free for specified student
  WISE> exit

WISE should accept an optional -e command line argument instructing it to create a Terminal that echoes input, so that you can use i/o redirection for testing from scripts.
You can't enroll more students in a course than its enrollment cap. You can't assign more courses to a professor than her teaching load. A student cannot take (nor can a professor teach) two courses that meet at the same time.
Anyplace type appears it can be replaced by file fileName . In that case the output should go to a file with that name. If the file already exists it should be overwritten.
Note that students can be identified either by name or by integer ID.
Note that students and professors (and even courses) might have the same name.

Input and output formats

Course meeting times are Strings of the form
```
	"MWF t"
	"TTh t"
```
where t is an integer in the range 9, 10, 1l, 12, 1, 2, 3, 4, 5, 6, 7, 8. There may be more than one space between the days and the time.
When listing a student's or a professor's schedule it would be nice to order the entries by course time: MWF 9, ..., MWF 8, TTh 9, ..., TTh 8. But this is not required. Don't spend time fussing with it until (almost) everything else you want to do is done. (There's a hint below that will make it easier when you do get around to it.)
Students and professors have just a single name, not a last name and a first name. That's unrealistic, but it makes input parsing easier and gives you more time to focus on getting a good set of classes.
Input and output use the String representations for three digit integer student IDs.
Format for the input files is specified in the samples given. You may assume that they are correctly formatted. That is, you don't have to write error handling code for parsing this input.
We will use different input files to test your application, so you cannot rely on the particular content of these examples. You might want to replace them with similar smaller files in order to test more easily or more thoroughly.
The hash mark # serves as a comment character both in input text files and on the WISE command line.
Output files for the lists of all courses, students and professors should have the same format as the input files for those objects. You can test that by writing them out and then trying to read them back in again when you restart WISE.
Here are sample outpuf files for the individual class lists and student and professor schedules (links may be broken until they are available):

Design/construction strategy

You can only succeed at this assignment if you design/code/test in small steps. Here are some suggestions.

Make a list of the classes you know you will need. (You will discover others later on - your list need not be complete yet.) Start each one by providing appropriate fields, with getters and setters, a constructor and a unit test. Make sure each compiles and runs and is properly commented and formatted from the start.
We have studied several applications with the same logical structure:
```
	create some collections of objects 
	   (BankAccounts, Users and JFiles)
	loop until exit
	   get command from keyboard, act appropriately
```
WISE has the same architecture, so you should be able to imitate logical patterns you find in Juno and the Bank.
Think about the messages that objects will need to send to each other (and to themselves). For each, write pseudocode, as a comment. When you're ready write code and test, one method at at time. If you name variables and methods well you can probably delete the pseudocode.
If you find yourself writing several methods that look identical or almost identical, think about how you can rewrite so that the common code is in just one place - maybe it's a time for inheritance, or for a method somewhere you can invoke from several places.
At each natural stopping place, turnin your work so far, and copy your work so far to a safe, labelled place. That way you can always return to something known to work if you start down a path you don't like.
Don't be stingy with classes. For example, consider representing a course meeting time as an instance of a TimeOfDay object rather than as a String like "MWF 2". If you do this you will want to override the equals and toString methods from Object.
Keep your memo up to date. You need not write down every last little detail, but do keep track of major important decisions you make, and of the times when you change your mind. Diary form might be a good idea.

Features not specified.

Real software almost always wants more features. We've seen that in all the applications we've studied this term. It's easy to imagine what a real WISE would look like. Here are some ideas that haven't been included. If what's been asked for so far turns out to be too easy we can add from this list. Or you can do some of it as optional work provided the required part is complete.

Students and professors should be able to log in, with secure passwords that they choose and can change. Each should have access only to his or her information.
WISE should have a graphical user interface.
WISE should be persistent, so that when you leave and return it remembers enrollments and assignments.
A real WISE system would have an administrator who could create courses and students - like the banker in our Bank application.