Project

  • Due Jun 6, 2023 by 4:30pm
  • Points 60
  • Submitting a file upload
  • File Types zip

The primary learning objective of this course is to understand CS as a discipline, understand critical perspectives on the discipline, and critically examine CS teaching and learning from these critical perspectives.

Why then is there a programming project that's more than half of your grade?

Three reasons:

  • Self-efficacy. For better or worse, programming is a central part of CS content knowledge, and so it's important that you feel confident, excited, and courageous about doing it. So much of the discipline of CS signals that you should feel the opposite of these things; this course tries to counter that by giving you a supportive, joyful, and creative experience programming, with plenty of room for learning, growth, curiosity, and tinkering.
  • Perspective-taking. If you engage students in programming, it's important to have perspective on their experiences. But as you develop critical consciousness of computing in society, it's also important to take the perspective of those who create computing for society. We'll use this programming project to help you not only develop your own experiences programming, but see programming from these other perspectives. We'll examine all of these perspectives in class, using your experiences to help you see programming from many viewpoints.
  • Critical consciousness. While its easy to critique computing for its failures and limitations, it's harder to critique them in ways that account for the realities of the medium. By immersing you in the medium, I hope you'll gain an appreciation for precisely where the limits in computing come from and why they are hard to overcome.

If that sounds scary, that's okay! Not knowing how to do something, trying, failing, learning, and trying again are an authentic to all programming, even the most expert of programmers.

That said, you won't be programming alone. We'll scaffold your programming in this assignment in many ways:

  • AP CS Principles portfolio. Rather than design and program without constraints, you'll work within the constraints of the AP CS Principles portfolio assessment. It sets certain requirements on what you make and assesses certain qualities of what you make. We're not using this because it's a great assessment — on the contrary, its full of flaws that you'll discuss in the Assessment course — but because it will support the perspective taking goal above, giving you a sense of how students might experience programming within the bounds of a particular assessment.
  • Studio. Each Thursday, we will meet in person together to collaborate, share, and learn with each other. Some of this studio time will support your projects in the other courses and help you reflect on and navigate your field experiences. But we expect much of it to support your programming knowledge. We'll help you debug, guide you toward algorithms and data structures you might need, and help you with syntax and tooling issues. This will mirror the kinds of support you might give students, so we'll also be modeling a lot of pedagogy as we help you, and reflecting on that pedagogy.

AP CS Principles (AP CSP)

AP CS Principles Links to an external site. is one of many curricula that are used in secondary CS education. It's not the best curriculum or even an exemplary one, and there are numerous issues with the College Board and AP courses in general. But it a curriculum that has notably broadened participation in computing Links to an external site. where it is offered, largely because it approaches CS in a student-centered, creative, and multidisciplinary way (unlike AP CS A, which is a very narrowly framed Java programming course). There are also numerous providers of AP CS Principles curricula Links to an external site. using different programming languages and platforms and accompanying professional development. You can see how the College Board frames the course in this video:

You'll be working on the "Create Performance Task" portion of the AP CS Principles Exam. You can see details about this assessment on page 189 of the 2020 AP CS Principles Course Guide Links to an external site.. The general requirements of the task are:

  • At least 12 hours of class time to complete and submit everything.
  • Source code for a computer program that:
    • Provides instructions on how to use the program
    • Receives input from one or more of: 1) a person (e.g., via mouse, keyboard, touch), 2) a device, 3) an online data stream, or 4) a file.
    • Uses a list or set data structure
    • Defines and calls at least one function that takes one or more arguments and produces a return value based on those arguments. (Using an API does not count).
    • Uses an algorithm that uses sequencing (lists), selection (conditionals), and iteration (loops) to achieve some goal.
    • Provides some form of output (tactile, auditory, visual, textual) based on input
  • A video that displays your running program and demonstrates its functionality.
  • Written responses to the performance task.
    • Describe the overall purpose of the program
    • Describe what functionality is demonstrated in the video
    • Describe the input and output of the program demonstrated in the video
    • Describe how data was stored in a list, how the list was used by an algorithm, and how the list was used to manage complexity
    • Describe how a function that was defined, where it was called, how it contributes to the functionality of the program, and how the function's algorithm works.

We'll adapt this in a few ways:

  • You'll work both in class (during studio) and out of class.
  • You'll submit your actual source files, not a PDF of code.
  • Instead of writing descriptions above, your source code must include comments that explain all of the above in the appropriate place in your code.
  • Instead of creating a video, you'll give a 10 minute presentation in the final studio of the quarter, so that your peers and I can understand how your program is built. You'll structure your presentation as a code walkthrough: start by talking about the input the program can receive, then explain how it processes it, then explain what output it produces. You might repeat this for many different types of inputs, to demonstrate your program's different behaviors. Leave 3 minutes for questions from peers. (You may create a recording if you cannot attend class).

You'll also have one additional requirement not currently part of the AP CSP exam:

  • You must submit a <1,000 word reflection that discusses:
    • How your programming process evolved throughout the quarter
    • How your programming self-efficacy evolved throughout the quarter
    • How you feel about the technical quality of your program (e.g., to what extent is it comprehensible, organized, correct?)
    • How you feel about the sociotechnical qualities of your program (e.g., to what extent is it useful, biased, fair, oppressive?)
    • How you feel about your ability to facilitate students writing similar programs, including both skills you have and skills you need to learn

Your final submission to Canvas should be a zip file that contains:

  • All of the source code for your program (as text files or screenshots for block-based code).
  • A file named README.txt that contains the written reflection above.

Choosing a project

There are many different things to consider when choosing a project:

  • What is your goal? Strengthen programming skills, evaluate a platform for teaching, learn a new programming language, create something of value for yourself, create art, play?
  • How much time do you have? As noted above, AP CS Principles expects a minimum of 12 hours of class time. That's a pretty small project, and can't be very ambitious. Do you want to spend more time? That might let you expand your ambitions. We can help you estimate time.

Choosing a programming system

Each of you may be teaching in different disciplines with different programming systems that might be relevant to those disciplines. Therefore, rather than limit you to a particular platform, you can choose any platform and I'll work with you to help learn it (and learn it myself if necessary) to help you succeed in the project.

Here are some programming systems that we recommend for different disciplines:

Designed for Learning

  • Scratch Links to an external site. or Snap Links to an external site.
    • Good for interactive 2D animations and simple games
    • Pros: Syntax errors are impossible; many users are teachers
    • Cons: Poor documentation, confusing error messages, poor tutorials
  • App Inventor Links to an external site.
    • Good for creating mobile applications
    • Pros: Authentic experiences on personal devices, many teaching resources
    • Cons: Complex APIs, tooling, and user interface, confusing error messages
  • MakeCode Links to an external site.
    • Good for low-fidelity 2D web-based and portable games
    • Pros: Simple tools, good error messages, many examples, some teacher support.
    • Cons: Lots of options to choose from, rapidly shifting documentation
  • Wordplay Links to an external site. — Amy's unfinished sabbatical project
    • For creating interactive text and typographic animations, media, and games
    • Pros: Centers accessibility, language inclusion, and simplicity
    • Cons: No tutorial yet, little documentation, and very much alpha software, so buggy. Only choose this if you want to live in the future!

Designed for Art

Designed for Software Engineers

  • Python Links to an external site.
    • Good for processing data and text in science and digital humanities contexts
    • Pros: No setup, popular professional language, simple web based editor
    • Cons: Syntax errors, confusing error messages, documentation intended for professionals
  • Java Links to an external site.
    • Good for building command line and server-side systems.
    • Pros: Used in AP CS A and college; relatively good feedback.
    • Cons: Syntax errors, confusing errors, complex object-oriented programming concepts.

We recommend using Repl.it Links to an external site. for these to avoid complex installation and configuration requirements.

Designed for Math

And there are hundreds many more to choose from and learn; ask us if none of the options above sound interesting.

Timeline

It can be hard to plan a programming project on a timeline. Here's a rough guide about milestones to reach each week:

  • Week 1: Choose a programming system
  • Week 2: Prototype a design (without code)
  • Week 3: Finalize a design (without code)
  • Week 4: Plan your program (with comments)
  • Week 5: Implement, verify, debug (with code)
  • Week 6: Implement, verify, debug (with code)
  • Week 7: Implement, verify, debug (with code)
  • Week 8: Document in comments
  • Week 9: Reflect, submit, prepare presentation
  • Week 10: Present

That breakdown gives you a sense of how you should spend your time, with a few weeks on design, a few weeks on implementation, and a few weeks on documentation, reflection, and communication. Since this class is only 3 credits, you'll have 6 hours out of class, and I expect at least 3 of those to be reading and discussion preparation. That leaves about 3 hours a week to work on your project and about 30 hours overall. That should be enough for the small project the AP CSP exam requires.

Grading

This project is graded as satisfactory or unsatisfactory. A satisfactory project:

  • Meets all of the requirements
  • Includes a working, complete, and documented program
  • Includes a clear explanation of the program
  • Includes an insightful reflection on future learning
1686094200 06/06/2023 04:30pm