Learning Objectives

This document is a map of what you should be able to do as the course progresses. Each week lists the skills you are expected to carry forward: not a list of assignments, but the understanding the assignments are meant to build. The course is organized into units, and each of the first five units lines up with one quiz. The final unit is your project, and the final exam covers everything. Use this page to gauge whether you are making good progress.

All quizzes and exams are done without AI. The modality alternates: Quizzes 1, 3, and 5 are on paper, so you must be able to read and reason about code by hand. Quizzes 2 and 4 are on a computer, where you write and test a program before submitting. The final exam is both: a written half done on paper, then a second half on a computer. Some weeks train you to trace code in your head, and others train you to write and test working code. The objectives below tell you which is which, and the exams check both.

Two goals that run through the whole course

These goals are not tied to any single week. They develop from the first week to the last, and you will practice them continually through weekly reflections and class discussion.

Learning how you learn. Each week you will describe how you studied, what you understood, and where you struggled, and you will adjust your approach based on feedback from your instructor and your classmates. You have freedom to choose how you study outside of class: readings, practice problems, videos, guided work with AI, other approved activities. Part of the course is discovering what actually works for you.

Using AI effectively. You are encouraged to use AI as a study aid outside of class. Over the semester you should become able to tell the difference between using AI in a way that builds your understanding and using AI in a way that replaces that understanding. The test is simple: quizzes, the final exam, and your ability to explain your own project all require you to program without AI. If your practice has built real understanding, that will show; if AI has substituted for your own understanding, that will show too.

Unit 1: Getting Started

Week 1: Your development environment

Set up and use the tools of the course: write, edit, and run Python programs in Thonny; work at the Linux command line; navigate the file system using paths; use ssh to reach the computer lab remotely; and use git to keep your files in sync between the lab machines and your own laptop. (Setup and workflow—not graded, but essential.)

Week 2: Statements, input/output, and errors

Write a program that reads input with input(), converts it to the correct type, and prints output with print() that matches a required format exactly. Import and use functions from a standard-library module such as math. Tell apart the kinds of errors you will meet: errors caught before your code runs (Ex: SyntaxError), errors that happen while it runs (Ex: ArithmeticError), and style violations reported by ruff.

Week 3: Expressions, types, and indexing

Predict, on paper, the type and value of an arithmetic or string expression, using +, -, *, /, //, %, **, string concatenation and repetition, and indexing a single character. Write expressions and f-strings that turn given inputs into a required numeric or formatted result. When an expression would cause an error, explain why and describe the type of error.

Unit 2: Decisions and Functions

Week 4: Branches and boolean logic

Trace and write conditional statements (if, elif, else, and nested conditions) and predict the value of boolean expressions built from comparison operators and the logical operators and, or, and not, including short-circuit behavior and operator precedence. Identify which values Python treats as true or false in a boolean context. Use help() to view the documentation of a built-in function.

Week 5: Functions, tuples, and documentation

Define and call functions using parameters, arguments, and return values, and trace how control passes from one function to another. Explain the difference between local and global scope. Use tuples to group a small, fixed set of values (such as an (x, y) coordinate or several values returned from a function) and unpack a returned tuple into separate variables. Try a function out on sample inputs by placing test code under an if __name__ == "__main__" block.

Unit 3: For Loops and Repetition

Week 6: For loops, lists, and ranges

Trace and write for loops that iterate over a list or over a range of integers, predicting how many times a loop runs and what it produces. Build and modify lists: use a loop to accumulate or filter values, and use list operations such as append(), index assignment, removal, and sorting to change a list in place.

Week 7: Visual Studio Code

Set up and use VS Code, the professional code editor you will use for more advanced work, as an alternative to Thonny. Open a project folder, run programs, and get ready for the pytest and debugger integration you will use next week. Use type hints to enhance the static analysis and type checking provided by VS Code. (Setup and workflow—not graded, but essential.)

Week 8: Strings, dictionaries, and testing

Trace and write for loops that step through the characters of a string, to count, search, and build up results. Construct and update a dictionary to count or tally values: setting, getting, and updating values by key, and checking whether a key is present. Write pytest tests that check a function against ordinary inputs and edge cases.

Unit 4: While Loops and Text

Week 9: While loops and sets

Trace and write while loops for situations where you do not know in advance how many times you will repeat: validating user input, or repeating until a condition or a random event occurs. Identify the three parts of a loop: initialization, condition, and update. Recognize when a while loop is the wrong tool for a job a for loop should do. Construct a set, test membership with in, and use a set to remove duplicates or keep track of what you have already seen.

Week 10: Files and strings

Read from and write to text files. Slice strings and apply common string methods (such as split(), strip(), join(), and the case methods) to pull apart and transform text read from a file. Explain how strings are immutable (string methods return a new string rather than changing the original) and contrast this with lists, which can be changed in place, including when a list is passed into a function.

Unit 5: Structured Data

Week 11: Dictionaries

Use a dictionary to map keys to values, looking a value up by its key the way you looked up membership in a set, but now retrieving associated data rather than just testing for presence. Use dictionary methods, and iterate over a dictionary's keys, values, or items to group and summarize data. Read and write basic list, set, and dictionary comprehensions as a concise way to filter and transform a collection.

Week 12: Nested data structures

Navigate and manipulate nested data (lists of dictionaries, dictionaries of lists, and similar combinations) to pull out, filter, and combine information, including data loaded from JSON and CSV files. Given a description of how a data structure is shaped, write code that retrieves or computes a required result from the data.

Unit 6: Final Project

The last three weeks are your project. Class meetings become workshops: Week 13 introduces the project and gives you time to propose and plan it, Week 14 offers short lessons on special topics that projects need (for example, using a web API), and Week 15 is review for the final exam together with project presentations. The project is where the skills from the whole course come together on a problem you choose.

By the end of the project you should be able to:

Build a working program from your own specification. Take an open-ended goal in a domain that interests you (web, data, games, or something else), turn it into requirements you can actually implement, and produce a working program that meets the requirements.

Bring the whole course together. Combine what you learned in Weeks 1–12 (input and output, expressions and types, conditionals, functions, both kinds of loops used for the right reasons, the right container for your data, file and text processing, and navigation of nested data) in a program larger than any single weekly exercise.

Organize your code into modules and functions. Structure your program as well-named and documented functions with clear jobs, grouped into cohesive modules that reuse functions instead of repeating logic.

Test your own code. Write pytest tests that cover the different behaviors and edge cases of your functions, and use coverage to judge how thoroughly you have tested the code.

Debug systematically. When something breaks or a test fails, use the debugger and breakpoints to step through your code, inspect its state to find the problem, and reflect on the bugs you found and how you found them.

Account for how you used AI. Describe where and how you used AI on the project, tell apart the uses that helped you learn from the ones that would have replaced your learning, and be able to explain and defend every part of the program you submit.

Present your work. Show your project to the class and explain what the program does, the design choices you made, and what you learned.

The Final Exam

This exam is cumulative and covers the content of Weeks 1–12, and like the quizzes it is done without AI. The exam comes in two halves: the first half on paper, where you read and reason about code by hand and no computer is allowed, and a second half on a computer, where you write and test working programs. Because of that second half, skills like testing and debugging are checked on the final too, not only on the computer quizzes. Where the project lets you use tools, teammates, and AI as a study aid, the final is the individual check that you can read and write code yourself. Everything on the exam is something this page told you to expect.