Syllabus

Course Code: LAI 676
Instructor Name: Emma Q. Brown
Format: Remote, asynchronous with weekly small group meetings
Email Address: eqbrown@buffalo.edu
Office Hours: TBA after student survey (Run by Varun)
Office Location: TBA after student survey
Credits: 3

Course Description

This introductory course on computer programming simultaneously teaches beginners the fundamentals of computer programming while using that learning experience as a context for developing pedagogical content knowledge of how programming is most effectively taught and learned. The course is also designed for graduate students in the social sciences, arts, and humanities who want to use computational methods in research or art.

The Pedagogy of Programming follows the curriculum of Making With Code, a two-year CS course developed around the principles of Constructionism and aimed at high school students. This course focuses on the first year of the curriculum.

Units

Our three units are: Drawing, Data Science, and Games. These units are a tour through three programming paradigms, or ways of approaching computational problems: imperative, functional, and object-oriented. Along the way, the curriculum is structured to gradually introduce you to the syntax of Python, basic computational ideas such as abstraction, data structures, and algorithms, as well as the tools and practices of the trade.

Mode of Instruction

The Pedagogy of Programming is remote, asynchronous with weekly small group meetings and in-person office hours.

Learning Outcome and Program Goals

This course's learning outcomes are closely aligned with the UB CS Teacher Preparation Program's CS Content Knowledge outcomes (and also with with the core concepts outlined in New York’s Computer Science and Digital Fluency Standards).

Impacts of computing
Computational thinking
Networks and system design
Cybersecurity

The course also focuses on several of the UB CS Teacher Preparation Program's CS Pedagogical Content Knowledge outcomes:

Supporting learner identities
Teaching with computational media
Feedback and assessment

The Pedagogy of Programming is part of all of UB's CS Teacher Preparation tracks, and will be of interest as an elective for teacher preparation candidates in other areas as well as doctoral students interested in computing education or the learning sciences.

Required Text and Materials

There are no texts required to be purchased for this course. All are accessible from this course website and from the Making With Code curriculum hosted at https://makingwithcode.org.

You will need regular access to a computer running Mac OS, Windows, Linux, or Unix. iPads are not sufficient. Chromebooks will work if you are allowed to install the Linux app. (In a pinch, you could complete this class using a Raspberry Pi.) You will also need a stable Internet connection. If any of these pose a challenge for you, please contact me and we'll figure it out.

You will also need to join our course Discord Server HERE.

Course Assignments

Group Meetings

You are expected to meet weekly in-person or virtually with a small group to collaborate on the labs. You will then post a short recap/reflection on your meeting in the Discord channel.

Labs

Each unit starts with a series of labs designed to be done in individually or in small groups, which introduce just enough new ideas to get you ready to work on an open-ended project.

Problem Sets

The problem set are designed to be completed individually to solidify skills and check your understanding.

Projects

Each unit culminates with an open-ended, interest-driven project in which students will apply the skills and knowledge learned during the unit to a project of their own design.

Evaluation criteria

Content knowledge - Does the project demonstrate the skills and knowledge addressed in the unit?
Process - Do the planning and process documents (e.g. pseudocode, sketches, git commits) show an active engagement and monitoring of the project’s development?

Journal

Keep a journal of your learning throughout the course and share it with Emma (eqbrown@buffalo.edu). The course journal will document both the process and the product of your learning.

The process will take the form of weekly reflections of at least 300 words and should address the following, in whatever format works for you.

Reflections on what you’ve been learning, doing, and thinking about this week.
Reflections on your intellectual, social, and emotional experiences over the week, as well as other facets.
Reflections on pedagogical structures and practices which mediated your experience as a learner. What might you use in your own teaching practice? What would you change?

The product will take the form of a single document with the following outline, following Kafai, Proctor, & Lui’s (2019) cognitive/situated/critical framework of CT and Brennan & Resnick’s (2016) concepts/practices/perspectives framework.

Introduction (write this at the end of the course)
Cognitive (Concepts)
Situated (Practices)
Critical (Perspectives)
Conclusion (write this at the end of the course)

Evaluation criteria

Specificity - Does the journal regularly document specific experiences, in sufficient detail that they could serve as the basis for later reflection?
Iterative growth - Does the journal build on previous entries, developing ideas and opinions?
Synthesis - Does the journal’s final product provide a coherent summary of the student’s CS content-knowledge learning?

Grading

A student’s course grade is the weighted average of assignment grades, with weights as shown in the table below.

Category	Weighting	Grading criteria
Group Meetings	5%	Graded on weekly particupation.
Labs	20%	Graded on completeness.
Problem sets	20%	Graded on correctness.
Journal	20%	Graded according to rubric.
Projects	35%	Each project graded according to rubric.

Getting Help

During this course, it is normal to come across errors and sometimes get stuck. If this happens, don't hesitate to seek help from your classmates and your instructors. The best way to seek help is through the Discord community. Post as much detail as you can in your message and and we will help you work it out. We also encourage students to help each other out, especially when they have faced similar issues before.

Here are some details you should include in your message:

The complete error message: The full text of the error message (which can often be quite long!) is important to narrow down the source of the problem. When posting to Discord, make sure you format your error messages as code. See the Discord formatting instructions on how to do this. You should avoid sending pictures or screenshots of code.
The context: What part of the code do you think is causing the error? The error message will often include a series of file names and lines numbers. This is called a "stack trace", and it represents the series of function calls that led to the error. Usually just one or two lines in the stack trace will be from your code, but that is usually enough to tell you where in your code the error is coming from.
What you've tried: What did you do to try and solve the problem? What helped and what didn't?

Remember, if you are stuck on a problem for a long time, take a break and come back to it later.