The Final Project

Assigned

Monday, 11 November 2024

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 Overview

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.

Milestone 2 Details

You will submit a short write-up outlining your plans for the project.

Title. Write a descriptive name for your project.

Contributors. Write the names of all team members and your team name.

Topic Description (5-7 sentences). Describe the project you intend to implement. In your writing, give your audience a clear vision of what your program will do, including its input, output, and user interaction (if applicable). If your program includes a visual component, include a simple hand drawn sketch or mock-up of what the program’s output or interface will look like.

Architectural Outline. Describe, using words or diagrams, the components of your program. You do not need to write any code yet. Rather, illustrate conceptually what components the code needs to have and how they will interact with each other. Your architectural outline will serve as a plan for implementing your future code, but you will not need to follow it exactly.

Submission on Gradescope.

• PDF format.
• 1-2 pages. (You will probably need a 2nd page only if you have figures.)

Milestone 3 Details

You will decompose the program outline into functions and work on the implementation of your code.

You will submit a scamper file and a short write-up demonstrating your progress on the project.

Write up

• List at least 5 learning objectives from the course syllabus that will appear in your program.
• At least two of them should be from Unit 2 or 3.
• For each of your 5 chosen learning objectives:
  • Indicate which part(s) of your code will implement it by naming at least one of the functions in your program.
  • Describe why the given learning objective is needed for that part of the code.
• Challenge topics
  • When selecting your learning objectives, make sure that each member has at least one “challenge topic,” that is, something they will work on that is not easy for that team member. Say which ones those are, e.g. “recursion is Leah’s challenge topic.”
  • By the end of milestone 4, each team member should contribute meaningfully to the implementation of the code for their challenge topic.

Skeleton Code

• The term “skeleton code” refers to a working outline of a program in progress.
• Your program should be able to compile without errors and run, even if it does not do very much yet. (As an example, consider the starter code that we provide for labs. The key functions in the starter code often contain placeholders instead of functional code, and the tests may not pass yet, but the scamper file can execute without errors.)
• Your skeleton code should demonstrate functional decomposition of your program into parts.
• Skeleton code is a minimum. It would be great if some parts of your program are fully implemented, documented, and tested!

Submission on Gradescope

• Write-up: PDF format, one half to one page
• Skeleton code: .scm format

Tips

• Make sure that all team members are in constant communication about responsibilities and meeting times. Better to over-communicate than under-communicate.
• Work on your code incrementally. Run it frequently and make sure each part works before going on to the next part.
• It is normal for programmers to “break” their code as they are working on it. Periodically save working versions of the code in a separate file in case you have to go back to an earlier working version.
• Get started on the documentation and testing early! Those components can help in the process of writing code, rather than being tacked on an afterthought.

Milestone 4 Details

You will submit your completed software artifact and the slides for your project presentation.

Code

One or more Scamper programs that address the problems you wish to solve. The programs should be complete, well documented, well tested, and well-formatted according to the course style guides. They should run without errors.

Presentation

• On Wednesday or Friday, you will give a presentation of at most 8 minutes about your project.
• In the presentation, you should
  • give an overview of your work
  • discuss your design plans
  • highlight one or more pieces of code that you are proud of
  • be prepared to answer questions from the audience
• As the breakdown for your 8 minute presentation, we recommend planning about 4-6 minutes to describe your work and about 2-4 minutes for your live demo. Audience Q&A can take place outside the 8 minutes.
• All members of your team must have meaningful speaking parts in the presentation.
• You will submit the slides for your presentation in the Milestone 4 submission via gradescope, along with your code.

Tips

• Rule of thumb is 1 slide per minute (give or take), equating to about 4-6 slides (give or take)
• Make sure all text on your slides is large enough to be easily readable from the back row
• Make sure that fonts and colors on your slide are legible. Consider color blind viewers who may not be able to distinguish between various colors.
• Don’t use stock imagery in a place where you could instead show a meaningful visualization of your work
• Practice your presentation by plugging your laptop into the podium in our classroom before the day that you present

Submission on Gradescope

• Slides in PDF format
  • Note that slides in .pptx, .key, and various other formats are not readable on gradescope. You may present using any format of slides, but you must convert to PDF to submit via gradescope.
• Scamper code for your completed project

Milestone 5 (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 to each? Describe your contributions to the code base, project management, team coordination, documentation, milestone write-ups, etc.
• 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!