Final project
Contents
Overview
The final project must be a Java application that you design and build. You have a lot of flexibility in what you do, as long as it makes sense, is of a substantial size, and meets the constraints laid out below. You will be designing and implementing your project according to a series of graded milestones, also laid out below.
Here are a couple example projects.
Rich text editor. A text editor with the ability to bold, underline, etc. The GUI allows editing, saving, and opening. The CLI allows the user to specify a file or directory to open in the GUI editor, or to convert a RTF document into plain text or HTML.
Data visualizer. Uses basic graphing libraries to plot data from CSV files (where the character separator can be custom set) and save the plots as images. The CLI allows specified files to be opened in the GUI with specific options (e.g., plot type, separator, titles, etc.), and can also be used to save plots to an image file without even opening the GUI.
(Back to top)Project constraints
Your final project must meet the following criteria:
- incorporates an interesting GUI
- incorporates a CLI (can have different functionality than the GUI)
- uses a databases or JSON/XML/CSV data files (e.g., import/export data)
- contains full coverage jUnit tests
- uses one or more student-made API (from MP7)
- includes graceful error handling
- has a reasonable OO design
- is well documented (header, inline comments)
- has a well written JavaDoc API
- is interesting and creative
- uses only external libraries approved by the instructor
Milestone 1 (FP1): List of project ideas
Provide a list of at least three potential ideas for your final project. Write one paragraph (a few sentences) per idea describing what it would consist of. These are rough ideas, so do not get too bogged down in details.
See this Canvas page for a rubric and submission details.
(Back to top)Milestone 2 (FP2): Project sketch
Pick one of the applications you outlined for FP1 (or a new one!) and write a few sentence response to each of these questions:
- What will your application do?
- What's will the GUI look like? (use a program to draw the design, or draw it by hand and take a picture)
- What will the command line interface (CLI) look? (will it be interactive; if so, what will the menus look like? will it use flags and parameters passed in from the command line? etc.)
- What data will be stored and how (e.g., using a database or JSON/XML)?
- Thinking about the OO design of your application, list three potential classes you may implement and describe what they do.
See this Canvas page for a rubric and submission details.
(Back to top)Milestone 3 (FP3): UML Diagram
As we learned earlier in the semester, UML is a very useful tool in designing object oriented applications. Your application should have many classes, some of which may be interfaces or abstract. Create a UML diagram of your application's classes and how they relate. Each class should include all the usual information: name, type, attributes, method signatures, and access levels. jUnit tests should be included.
I strongly recommend that you do this in IntelliJ (you'll need the Ultimate Edition)—that'll make FP4 significantly easier. You can save the diagram to png or similar format and hand that in. You may also use another UML diagrammer or even something like PowerPoint.
Note that your classes should at least cover the functionality you described for your application in FP2.
See this Canvas page for a rubric and submission details.
(Back to top)Milestone 4 (FP4): Code Skeleton
Before you start digging into the nitty-gritty of implementing the code, make the skeleton. The skeleton should meet the following criteria:
- every class should be defined
- every method should have a stub—that is, a definition with only
a return statement (if the method returns something); the returned value
should be a dummy place holder (either
nullfor objects or a constant for primitive types) - every class and method should have complete JavaDoc comments above them—I should be able to generate the JavaDocs and it should appear as all is working, even though nothing is actually implemented.
- it should compile
Now, it turns out that if you used IntelliJ for FP3, then you're in good shape—you can easily generate all of the classes, methods, and even data member declarations from an IntelliJ UML diagram. You'll have to add the return statements and documentation, though.
See this Canvas page for a rubric. You should submit your Java files in a jar.
(Back to top)Milestone 5 (FP5): 30% complete
This one is pretty simple: 30% of your application should be implemented for this milestone. If your code has 100 methods, you should have 30% of them implemented.
See this Canvas page for a rubric. You should submit your Java files in a jar.
(Back to top)Milestone 6 (FP6): 60% complete
60% of your application should be implemented for this milestone.
See this Canvas page for a rubric. You should submit your Java files in a jar.
(Back to top)Milestone 7 (FP7): 90% complete
90% of your application should be implemented for this milestone.
See this Canvas page for a rubric. You should submit your Java files in a jar.
(Back to top)Milestone 8 (FP8): 100% complete
Your application should be completely implemented and ready to be used.
See this Canvas page for a rubric. You should submit your Java files in a jar.
(Back to top)Milestone 9 (FP9): Report
For this milestone, submit a well-written, five page report answering the following questions:
- What is your application?
- Why did you choose to build this application?
- What roadblocks did you hit along the way?
- How did you deal with them?
- What would you do differently if you had to build your application from scratch again?
- What do you feel you've learned from this project?
- What did you wish you had learned, but didn't?
Do not simply answer each question. Your report should be smooth with easy to follow transitions. Your audience is me and your fellow classmates.
See this Canvas page for a rubric and submission details.
(Back to top)Milestone 10 (FP10): Final Presentation
The final presentation serves as a way for you to show case your project to me, your classmates, and other faculty/staff members. You should approach it as follows. Pretend you are pitching your application to a potential customer. Your presentation should be snazzy and easy to digest. You should use some sort of presentation software and a demo should be include. Be sure to satisfy the following criteria (in addition to the rubric!):
- introduce yourself
- describe what your application is and why it is useful
- demonstrate either the GUI or CLI features, though make sure you explain the key functionalities of the other
- show the API
See this Canvas page for a rubric and submission details.
(Back to top)