CS 108 Final Project

The final project in CS 108 is an opportunity for you to showcase what you have learned in this class, and begin applying your newfound knowledge and abilities to a problem that interests you personally.

The final project can be done individually or with a partner (groups of 2 or 3 are encouraged; maximum group size is 3). In either case, I hope you consult with others in the class and with professors for help in design, implementation, and debugging.

Timeline (Milestones)

There will be six milestones for this project, designed to help you make steady progress. Due to the tight schedule, late submissions will be penalized per the course policy.

# Milestone Due Weight
1 Project Proposal Sat Mar 28 10%
2 Progress Report & Initial Code Sat Apr 11 20%
3 Code Check-in 1 Sat Apr 18 10%
4 Code Check-in 2 Sat Apr 25 10%
5 Final Code + Report Thu Apr 30 45%
6 Showcase (see below for times) 5%

All submissions are due by end of day (23:59) on the date listed. Milestones 4 and 5 do not accept late submissions.

Instructor check-in (required): Sometime around Code Check-ins 1–2, you must meet informally with the instructor (e.g., during lab) to discuss your project. You should be able to show what you have working and discuss your plans. Code submitted without a check-in will not be graded.

Details for each milestone are below:

Milestone 1: Project Proposal

If you are working with a team, list all names. Only one submission is needed per team.

Write a document (Word, PDF, etc., not Python code) of at most 2 pages that includes the following:

It’s okay if you don’t have everything fully designed; expect the project to take shape as you go. But note that the more work you do on your design, the less time you’ll have to spend writing the code (because you’ll implement more of it correctly the first time).

Checklist:

AI Policy:

Why this policy? Last year, students who used AI-generated code often had trouble explaining what it did, which showed they didn’t really understand it. Writing the code yourself is how you learn. Use AI to help you think, not to think for you.

What kinds of projects can you work on?

Almost anything, as long as it involves writing Python code! Games, simulations, tools, data analysis, education, art — it’s all fair game. The project should not be too easy or too difficult and should be completable by your team in about 6 weeks. Start small and grow it gradually. It’s better to finish a not-so-difficult project well than to not finish an ambitious one.

If you think you need more advanced user interactions than we’ve studied in class (print(), turtle, brython), talk to the instructor about options. Prefer simple tools.

Previous projects

Here are some examples of what students have done in prior offerings:

Ideas

Milestone 2: Progress Report & Initial Code

Submit two items on Moodle:

Progress Report (document)

Submit a document (at most 5 pages, Word/PDF/etc.) that includes:

Initial Code

Submit your code on Moodle. If you have more than one .py file, consider naming the main one main.py. Compress all files into a ZIP.

At this point you should have:

Include acknowledgments at the beginning of your main program in a docstring.

Checklist — Progress Report:

Checklist — Initial Code:

Milestones 3–4: Code Check-ins 1–2

Submit your code on Moodle in the same format as Milestone 2 (if you have more than one .py file, consider naming the main one main.py; compress all files into a ZIP).

Each code check-in will be evaluated based on the improvement over the previous submission (e.g., additional code, bug fixing, better documentation). List the improvements at the beginning of your main program in a docstring, for example:

"""
Improvements in this submission:
- Added the scoring function
- Fixed a bug where the game crashed on invalid input
- Added docstrings to all functions
"""

Checklist:

Milestone 5: Final Code + Report

No late submissions accepted.

Final Report

Submit a report (PDF, at most 8 pages) that includes:

  1. Title and author(s): An informative and concise title, and your name(s).
  2. Goals: What problem are you solving? Overall goals and specific subgoals.
  3. Data and Python data types: What kinds of data are relevant? What Python data types do you use?
  4. Algorithm design: Describe the algorithms you use to solve the core problems.
  5. Program design: A table of functions/classes you designed and their relationships.
  6. How to demo: Specific instructions for running a basic demo of the main functionality.
  7. Testing: What steps could someone do to check that your code works correctly? (e.g., if your program used to have a bug but now you fixed it, describe how you can test that it’s fixed. If you use assert statements, running the code may suffice.)
  8. Highlights: A few parts of the program that you’re proud of — something tricky you got working or how you organized your code.
  9. Process: A one-paragraph summary of your process for creating the code. Include at least one specific difficulty that you encountered and how you overcame it.
  10. What you learned: Techniques or Python topics beyond what was covered in class.
  11. Acknowledgments: Detail any help received, including links if applicable. (If none, say so.)
  12. Sharing: Would you be okay with sharing your project, and if so, how? Ideally we’d make a public gallery with all projects, screenshots, and code, but you could choose to go anonymous, share only screenshots or just the title, or restrict to future students.

Checklist — Final Report:

Final Code

Submit a ZIP file on Moodle that includes:

Checklist — Final Code:

Milestone 6: Project Showcase

During our final exam time, you will demo your project to the class:

We will divide up by rows. Each person will demo their project to others in the row. Each row will then nominate one project to show to the whole class. We’ll vote for the best project!

Although this event will feel pretty informal, you should still:

For a team project, each team member should be present and contribute.

Grading

Each milestone is graded by the checklists given above.

General advice

It is better to choose a project that is not overly complex and get it right than to choose one that is too complex and not finish it. I recommend finding a project you can implement in stages, so that at multiple points you have a “finished” project and can then decide whether to proceed to the next stage. Document these stages in your design document.

Testing

You can use assert to test your functions. For example:

def double(x):
    return x * 2

def is_close(x, y):
    return abs(x - y) < .001

assert is_close(double(2), 4)
assert is_close(double(3), 6)

Reuse vs Plagiarism

It can be very helpful to find an example we did in class (lab, homework, etc.) that is similar to what you want to do and adapt it. This is highly encouraged. Just note that you did so in your code documentation.

If you intend to use code from other people outside of the class, talk to us first and remember that we’ll grade you on the code you write, not on what other people write. If you do make use of existing code and libraries, be sure to clearly indicate who wrote what parts of the code; using code without proper attribution is a form of plagiarism.

Feel free to discuss ideas with us or with your classmates, but don’t copy code (i.e. plagiarize). Here are examples of what plagiarism looks like:

Consider these rules of thumb:

Note that these rules of thumb apply to the code supplied in this course’s materials as well.

Resources

Please feel free to ask the instructor for help in finding good quality resources for your project.

Datasets

Acknowledgments

These instructions were based on project guidelines by Dr. Victor Norman, Dr. Keith Vander Linden, and Dr. Rocky Chang.