Performance Task¶

Here’s a 10-day calendar and checklist to help students successfully complete their performance task. This calendar outlines the process from initial planning to final testing and submission, encouraging a consistent, structured approach. I’ve also included updates to the requirements and a daily log format for students to document their progress.

10-Day Calendar & Checklist for Performance Task Development

Objective: Develop a program based on your chosen language or block-based coding (e.g., Scratch, Blockly). This could be a game, tool, application, or any project that aligns with the course objectives.

Day 1: Introduction & Planning¶

Tasks:
- Understand the requirements of the Performance Task.
- Choose a programming language (e.g., Python, Java, Scratch, etc.).
- Brainstorm ideas for the project and decide on the type of program (e.g., game, interactive tool).
- Write a project proposal outlining the purpose of the program, basic features, and expected outcomes.
Checklist:
- Review Performance Task requirements
- Choose programming language or platform
- Brainstorm ideas for the project
- Write project proposal
Daily Log:
- What I did today:
  - (e.g., “Decided on creating a simple calculator program using Python.”)
- Challenges faced:
  - (e.g., “Struggled with deciding between Python and Scratch.”)
- What I learned:
  - (e.g., “Learning to define the purpose of the program before coding.”)

Day 2: Design & Conceptualization¶

Tasks:
- Finalize the program idea.
- Create a flowchart or wireframe of the program.
- Define the user interface (UI) and user experience (UX) if applicable.
Checklist:
- Finalize the project idea
- Create a flowchart/wireframe of the program
- Define UI/UX elements (if needed)
Daily Log:
- What I did today:
  - (e.g., “Created a flowchart outlining the steps for the calculator.”)
- Challenges faced:
  - (e.g., “Struggled with visualizing how the UI should look.”)
- What I learned:
  - (e.g., “Wireframing helps with organizing thoughts before coding.”)

Day 3: Setting Up Development Environment¶

Tasks:
- Install necessary tools or IDEs for the chosen programming language (e.g., VSCode for Python, Scratch for block coding).
- Create a new project folder and set up basic files.
Checklist:
- Install necessary tools/IDEs
- Set up the project environment (create folders, files, etc.)
Daily Log:
- What I did today:
  - (e.g., “Installed VSCode and set up the project folder for Python.”)
- Challenges faced:
  - (e.g., “Had issues with installing Python libraries.”)
- What I learned:
  - (e.g., “The importance of having the development environment ready early.”)

Day 4: Writing Initial Code – Basic Setup¶

Tasks:
- Start coding the basic structure of the program.
- Focus on implementing core features like user inputs, basic logic, or setting up sprites in block coding.
Checklist:
- Write basic program structure (e.g., loops, conditionals)
- Implement user input (or basic sprite setup in block coding)
Daily Log:
- What I did today:
  - (e.g., “Started coding the input handling and logic for the calculator.”)
- Challenges faced:
  - (e.g., “Had trouble managing user input correctly.”)
- What I learned:
  - (e.g., “Learning to handle inputs and feedback from the user.”)

Day 5: Core Features – Adding Key Functions¶

Tasks:
- Develop the core functions or algorithms of the program.
- Test each feature incrementally.
Checklist:
- Develop key features/functions
- Begin incremental testing (test as you go)
Daily Log:
- What I did today:
  - (e.g., “Implemented addition, subtraction, multiplication, and division functions for the calculator.”)
- Challenges faced:
  - (e.g., “Wasn’t sure how to handle invalid inputs.”)
- What I learned:
  - (e.g., “Built a more robust error-handling system.”)

Day 6: Adding Advanced Features / Enhancements¶

Tasks:
- Add advanced features (e.g., error handling, extra functionality, design improvements).
- Polish the UI/UX.
Checklist:
- Implement advanced features (e.g., error handling, extra functionality)
- Improve UI/UX design (if applicable)
Daily Log:
- What I did today:
  - (e.g., “Added error handling and made the UI more user-friendly.”)
- Challenges faced:
  - (e.g., “Balancing between functional and user-friendly design.”)
- What I learned:
  - (e.g., “A good design improves usability.”)

Day 7: Testing and Debugging¶

Tasks:
- Conduct thorough testing of all program features.
- Identify and fix any bugs or issues that arise.
Checklist:
- Test each feature individually
- Debug any issues
Daily Log:
- What I did today:
  - (e.g., “Tested the calculator with various inputs and fixed division by zero errors.”)
- Challenges faced:
  - (e.g., “Found some unexpected issues with input parsing.”)
- What I learned:
  - (e.g., “Testing helps ensure all edge cases are covered.”)

Day 8: Finalizing Code and Documentation¶

Tasks:
- Clean up code (remove unnecessary comments, refactor for efficiency).
- Write documentation (explain how the program works and any special features).
Checklist:
- Refactor code
- Write documentation (project summary, how to use, etc.)
Daily Log:
- What I did today:
  - (e.g., “Cleaned up my code and wrote a short documentation.”)
- Challenges faced:
  - (e.g., “Refactoring code took longer than expected.”)
- What I learned:
  - (e.g., “Clear documentation is essential for others to understand your code.”)

Day 9: User Testing and Feedback¶

Tasks:
- Ask peers or users to test the program.
- Gather feedback and make final adjustments.
Checklist:
- Conduct user testing
- Collect feedback and improve program
Daily Log:
- What I did today:
  - (e.g., “Got feedback from a classmate who suggested improving the error messages.”)
- Challenges faced:
  - (e.g., “Incorporating user feedback without overcomplicating the program.”)
- What I learned:
  - (e.g., “User feedback is invaluable for improving the program.”)

Day 10: Final Testing & Submission¶

Tasks:
- Perform final testing to ensure everything is working as expected.
- Prepare and submit the project.
Checklist:
- Final test
- Submit project
Daily Log:
- What I did today:
  - (e.g., “Ran final tests and submitted the project.”)
- Challenges faced:
  - (e.g., “Making sure everything was properly packaged for submission.”)
- What I learned:
  - (e.g., “A final round of testing is always crucial.”)

Performance Task Requirements Update:¶

Performance Criteria:
- The program must have at least three main features.
- The program must be error-free and user-friendly.
- The program should include user interaction (e.g., input, buttons).
- The code should be well-commented and organized.
- Students are encouraged to use advanced programming techniques where possible.
Documentation:
- A brief report explaining the project, the development process, and challenges faced must be submitted alongside the code.

This calendar provides structure while allowing for creativity and problem-solving. It encourages students to log their daily development process, which helps them reflect on their progress and identify areas for improvement.