The Final Project

To conclude our semester, you will embark on a final project with 3--4 of your peers, developing a final project aligned with the themes of the course:

Requirements and Topics

In your project you will develop one or more Scheme programs to explore an area of multimedia related to your group's interests. For example, you might consider:

  • Creating a collection of musical compositions around some theme that might be out of reach for a human to perform on their own.
  • Creating a piece of art using multiple complex transformation over images.
  • Developing a hybrid human-computer performance piece, e.g., a musical composition with Scheme performing one of the parts, or even a dance or stage performance that incorporates Scheme programs in some way.
  • Building an interactive program, e.g., a game, with image and/or audio components.
  • Writing a program that performs an analysis over an image, e.g., detecting the edges of an image.
  • Combining art in music in a novel manner, e.g., a visualization of a sound wave.

The possibilities are endless and only limited by your imagination!

In terms of requirements, you will produce three major products:

  • A software artifact, i.e., one or more Scheme programs that accomplish your goals.
  • A short presentation of your work that you will deliver in the final week of the course.
  • An individual reflection on your work, to be turned in by the end of the semester.

Beyond these products, we do not have specific requirements about program size, using particular libraries, etc., so that different groups have flexibility in exploring the space of digital audio. Instead, we will be coaching you through the project milestones to add in sufficient complexity and depth, in particular, with the program that you develop, so that your final work demonstrates your knowledge of the core programming concepts of the course.

Project Milestones

To ensure that you are making appropriate progress on your final project, we will have several milestones, i.e., mini-deliverables for your group to produce. We will outline the details specifics of each deliverable in subsequent milestone deliverable write-ups.

  • Milestone #1 (Friday 11/15): groups are formed and project topic brainstorming begins.
  • Milestone #2 (Friday 11/22): identification of a topic for the project and an architectural outline of the program(s) you will need.
  • Milestone #3 (Monday 12/2): decomposition of the program outline into functions and a partially-completed program.
  • Milestone #4 (Tuesday 12/10): software artifact and project presentation is due.
  • Milestone #5 (Friday 12/13): individual reflections are due.

Final Deliverables

The final deliverables consist of three artifacts:

  1. One or more Scheme programs that address the problems you wish to solve. The programs should be complete and well-formatted according to the course style guides.
  2. A presentation no more than 8 minutes in length giving an overview of your work along with a demo or performance. You will produce a slide deck for this presentation and turn it in. Be prepared to answer questions from the audience.
  3. A short reflection on your work describing the problem you solved, your specific contributions to the project, and a bug that you personally encountered in your project and how you fixed it. These reflections will be completed individually and will reflect each individual's contribution to the overall project.

Final Reflection

Your final project grade will come primarily from your final reflection paper for the course. Note that the final reflection is an individual deliverable. You should work independently on your reflection so that the writing reflects your interpretation of your project. You should not collaborate with your group members on any part of this reflection! Furthermore, you should not use a large language model, e.g., ChatGPT, to help you author your reflection in part or whole.

Your final reflection should be a written paper meeting the following specifications:

  • PDF format.
  • At least 500 words and no more than 750 words in length.
  • 1" margins, 12 pt font, double-spaced.

Your reflection must include the following four parts:

  • Overview. Give a brief overview of your project in your own words: what did you build and why?
  • Architecture. Give a brief overview of your project's architecture: how did your group break down the problem into components?
  • Your Contributions. Give a description of your contributions to the project: which components did you contribute code to and how much code did you contribute to each?
  • Bug Log. Give a description of a bug that you personally encountered during development and how you systematically solved the issue. (More requirements below.)

Overview, Architecture, and Contribution sections should be in paragraph form.

In the Bug Log, you are encouraged to use a mix of paragraphs and numbered steps to best communicate your process. Your Bug Log should answer the following questions:

  • What did you initially observe that indicated a bug was present?
  • How did you fix the bug? You should describe the bug-fixing process as a cycle of the following two steps until a solution was found:
    • What steps did you take to understand and diagnose the issue?
    • What did you do to fix the bug? Did it succeed?
  • In hindsight, what should you have done to avoid introducing the bug in the first place?

To answer this question, you should choose a bug of substantial breadth and difficulty that you required multiple attempts of the "diagnose/fix" cycle to address the bug. Such bugs should be logic errors, i.e., bugs that arise because your strategy to solve a problem was wrong, not because you mistyped a construct.

Grading

Our goal is that if you do the work and follow good habits, you should get at least an M.

There are no redos available for this project.

  • Excellent:

    • Project code is high quality both in terms of functionality (i.e., the code accomplishes the task at hand) and style.
    • Project presentation covers all of the required points, involves everyone in the group, and stays within time budget.
    • Personal reflection is high quality, covering all required points and is evident of reflection on the software development process.

  • Meets expectations:

    • Project code is functional (i.e., the code accomplishes the task at hand) but may have some bugs or substantial style issues due to lack of revision.
    • Project presentation covers all of the required points.
    • Personal reflection covers all the required points but does not discuss them at sufficient depth.

Self-Checks

Problem: Brainstormin' (‡)

Brainstorm no less than three project ideas for your final project. Make sure to bring your ideas to class to share them with your group!