During the rest of the semester, you will have the opportunity to work on an individualized programming project in an application area of interest to you. There are four stages to the project, each of which requires you to submit work that will be graded. This page provides overall guidelines for the project and for the four stages, and lists some possible project ideas that you may consider. You are allowed to work in pairs on this project, although the final program must be more extensive in this case, and you will need to document the contributions of each partner. Additional guidelines regarding joint projects are given below. Here is a gallery of some previous CS230 final projects.
For this programming project, you will design, implement, and document an entire program largely from scratch. You can receive advice and help from the Instructors on your design, implementation, and testing, but you should complete the programming on your own as much as possible. You are allowed to use any of the standard classes that are in the Java SDK as well as any code that has been created or provided in CS230 this semester (for example, the implementations of various Abstract Data Types that you use in your program). It is expected that all other parts of the program will consist of code that is developed by you from scratch. Unless you are given explicit permission from one of the Instructors, it is not acceptable to use code from other resources, such as books, the Internet, or previous semesters of CS230, in either an original or modified form. Use of code from these other sources without permission would be a violation of the Honor Code.
Your program should use at least two of the following abstract data types covered in class: list, vector, stack, queue, graph, tree, and table. Your program should also include multiple class definitions. Although this will vary between projects, there should be at least three new classes that you define (in addition to the classes that are part of the implementation of the ADTs). Many projects will require or be enhanced by a graphical user interface (GUI). If your project involves the manipulation of a large amount of data, you may want to store this data in a text file. You are expected to write a fairly extensive program that is larger than the programs that you completed in assignments during the semester.
Due: Thursday, April 12
For the first phase of the project, you should hand in a description of your problem and an outline of the overall structure of the program and its use of data structures. This initial description can be written in English, although it is OK to describe some of these components in Java. The description should include the following: main()
method. This list should include
the classes that implement the ADTs that you plan to use. Note that as you
proceed with your program development, you may discover other classes that
would be useful to define for your application.
If you are unsure of what to include in your initial description, please ask one of the Instructors. In fact, before the due date for Phase One of the project, you are encouraged to meet with an instructor to discuss your choice of project topic and data structures.
Due: Thursday, April 26
In this
second phase, you will submit a detailed skeleton of the entire program, with some
completed code. The amount of completed code should be about 25% of the
anticipated final size of the program. Even if the code is buggy, you should
submit anything that you have written, so that we can provide as much feedback
as possible. In your skeleton, every class definition should have comments
indicating its purpose and should have all of the instance (or class) variables
specified, with comments added about their purpose. There should be at least a
complete header for every method that you plan to define, and a comment about
what the method will do. The header should indicate whether it is an instance
method or a class method, the type of value returned by the method (or the word
void if the method does not return
any value) and should specify all of the inputs to the method. Your main()
method should include all the
method calls that you expect will be made at the top level of your program
execution. If you have made decisions that deviate from your initial plan
submitted in Phase One of the project, include a brief explanation of your
decisions.
Your skeleton should be compilable and it should be javadoc-compliant.
The material you will provide for Project Phase 2 is similar
to what you provided
for Assignment 5 (Problem 2), with some additional code filled in.
Due: Tuesday, May 1
During the final labs of the semester, each of you will share your project ideas with the rest of the lab group. It is expected that you will not have a completed program at this point, but you can describe your general problem or application, choice of data structures, and user interface. You might also comment on what aspects of the project were especially interesting or challenging. You should prepare in advance to give a 5 minute presentation that clearly conveys to your classmates, what you are doing in your project.
Due: To be completed no later than Tuesday, May 15, at 4:30pm
In this final phase, you should submit your final, completed, and working
program. Submit a hardcopy of
all of the code files in your project, as well as a description of how to run
your program. If parts of your program do not work, or are not working as
originally planned, provide some additional notes about this. Hand in an
electronic copy of the entire program directory, including an electronic file
with instructions on how to run the program, in your individual drop directory
on puma using the submit program (you may verify with
your instructors that the
directory is complete after dropping it off). Your final program should
encompass principles of good program design, such as the effective use of
classes and methods, informative names for variables and methods, and code that
is efficient and concise. With regard to documentation, you should provide a javadoc-compliant
comment at the beginning of every method, describing what the method
does, and at least one comment at the top of every class file, briefly
describing the class and its purpose. You should also arrange a time to meet
with your instructors to demonstrate your final program and talk about your
experience with its development.
It is possible for two students to work together on a single programming project. In this case, the size and complexity of the planned project should be more substantial than what is expected of a typical single-student project, requiring about twice the amount of programming effort as the single project. The project ideas listed below are all examples of programs that have been completed by single students in the past. These ideas can also form the basis for joint projects, but you should work closely with your instructors during the early phases of the project, in order to make sure that the plan for the project is substantial enough to support joint work. In addition, the Phase One and Phase Two submissions should include a plan of work that indicates how the programming effort will be distributed between the partners. Some programming for a joint project can be done together, but there should be parts that each individual student is largely responsible for developing. As the program is written, the efforts of each student should be documented in the comments to the code (i.e. each class file should include a comment stating which student was primarily responsible for its implementation). This kind of additional planning and documentation is common in real-world software development projects that are implemented by a team of programmers.
The following are some initial project ideas. They may be helpful in getting you thinking about the project you want to implement. You are welcome to choose a project outside of this list, but should discuss your idea with an Instructor.
Build a program that allows a user to play a game. If you want to do a card game, you need to choose one that is much more complex than the War card game, because this existing implementation already provides large pieces of code that are relevant to many card games. If your favorite game is too complex to implement, you may change the rules to something more manageable.
Write a program that allows a user to work with a database of stored information about a particular topic. The user should be able to add new entries to the database, modify entries, and retrieve information, and interact with the program through a graphical user interface. Some sample application areas include maintaining a database of student records, a store inventory, a personal calendar, or an address book. You need to think about how you can add an aspect of complexity to the application so that it goes beyond the straightforward application of the basic table operations that we discussed in class. Such complexity may be incorporated through the nature of queries that the user can make about the data or knowledge stored in the database.
Write a program that simulates the behavior of a complex system, analogous to the printer simulation but much more elaborate. Some example systems that you could model include traffic flow at a 4-way intersection, flow of planes and passengers at an airport, or flow of patients in a large hospital.
The general task in search problems is to find a path from some point of origin to some destination point. The maze search problem was one example. You could build a GUI around a maze-solving program that would allow the player to solve a set of mazes. When the player gets stuck, the program could suggest a move to help the user. Other examples include a program that uses a database of flight information for an airline to determine a sequence of flights that a traveler could take to get from a city of origin to a desired destination, or a program that solves puzzles of some sort.
Build a program that embodies expert knowledge about a domain, and can use this knowledge to make inferences from data provided by the user. For example, a simple medical expert could collect data about a patient's health and try to diagnose the cause of the patient's illness. An expert system could also identify a class of objects based on observed properties, or make decisions about actions to perform in response to a current situation. Many expert systems build their knowledge into simple rules, such as those used in the Zoo animal identification program.