In this final project assignment, you will conceive of, design and implement a GUI-based Python application of your choice. Examples include the following:

• An Animation Controller - Build a GUI controller for an animation of your choice.
• A Simple Game - Build a GUI controller for a simple game of your choice (e.g., a board game like memory or an image-based guessing game).

We will discuss the components and complexity required for this project. You can find some fully-implemented sample applications here: code/samples/* and some images of past projects.

Deliverables and Grading

The following project “deliverables” are required:

1. Project Proposal - This is a brief, written proposal for your project.
   • Grading: 2%
   • Due: Submitted along with a weekly homework assignment (as specified by your instructor).
2. Project Design - This is a planning document for your project.
   • Grading: 2%
   • Due: Submitted along with a weekly homework assignment (as specified by your instructor).
3. Project Walkthrough - This is a walk-through of your project code with one of us.
   • Grading: 3%
   • Due: by 5:00pm of the reading recess day
4. Project Showcase - This is a showcase in which everyone exhibits their final project.
   • Grading: 3%
   • Due: by the beginning of your final exam period
5. Project Submission - This is your final submission of all your project code and resources.
   • Grading: 90%
   • Due: by 5:00pm of the day of your final exam period

Project Complexity

We will grade, in part, on the significance and complexity of your project. Generally speaking, here is a breakdown of the likely grading for different sorts of projects:

• A-ish Grade — Strong applications that are either unique (i.e., not based on the sample programs) or are B-ish projects (see below) extended to include some additional interesting features, e.g.: file reading/writing (e.g., leader board); timers; file-based difficulty levels; …
• B-ish Grade — Solid applications that are similar in overall structure to the sample programs but have some simple additional features, e.g.: Connect Four; graphical hangman; memory; SpaceInvaders-type game with significant upgrades to the ParticleSimulator; … ; common features include: scoring; complexity levels; timers/timing
• C-ish Grade — Basic applications that run and extend one of the sample programs in some interesting way, e.g.: CountryGuess with different kinds of clues (picture clues) or questions (math puzzles); ParticleSimulator with different kinds of particles/creatures/behaviors; non-graphical hangman; …
• D-ish Grade — Weak applications that are barely working (with program crashes, bugs, etc) or are minimally modified versions of our sample code, e.g.: CountryGuess with different questions; ConnectFour that is mostly just a 4x4 TicTacToe; SpaceInvaders that’s mostly just a re-skinning of the ParticleSimulator; …

For full credit, projects must be properly designed, implemented, tested and documented.

Reuse vs Plagiarism

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.

To help redirect your attention from seeking help from outside sources (e.g., other people, websites, generative models), we require that you build your final project using the tools and practices covered in this course. If you’d like to add a feature that goes beyond what we’ve, talk to us first.

As a reminder (from the policies), you must work on your own for this project assignment. 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:

• You copy a program from an online source, change some small things (e.g., variable names, output messages), and submit the code without attribution.
• Your roommate writes some code, which you add to your program. You add documentation that shows you understand their code, but never indicate the source of the code.
• You find an online tutorial that walks you through the construction of a system that you then submit without attribution.
• You use a generative model (e.g., ChatGPT) to produce your code, review it, perhaps edit it a bit, and the submit it without attribution.

Consider these rules of thumb:

• If you found it efficient to use copy/paste or use a generative language model to create more than one or two lines of your application, you must document the original source of the code.
• If the moment you figure out how to do something occurs while you are looking at a website or at the output of a generative language model, you should document that website.

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