Working Practices
Learn by Doing
Programming is easiest to understand when you actively run code.
Reading about an if statement, a loop, or a function is useful, but most of the learning happens when you run a small program, predict what it will do, check the output, and adjust. The same is true for tracing: a program becomes much clearer once you walk through it line by line with a specific input in mind.
When possible:
- run the example programs in the sandbox,
- predict what a program will print before running it,
- and modify one line at a time and see how the output changes.
It is usually more effective to work on each course part multiple days than to try to finish everything in one sitting. Programming concepts often become much clearer after a pause and a second pass.
A Useful Rhythm for Each Part
A practical rhythm for most parts of this course is:
- read the regular chapters in order,
- complete the chapter-level exercises as you go,
- then complete the project checkpoint for that part,
- and finish with the recap quiz and feedback form.
This order keeps the project from becoming the first place where a new concept appears. It is usually much easier to apply functions, loops, or files in the project after first meeting them in a smaller exercise.
Distinguishing the Threads
The course uses two example threads.
- The regular chapters use small, focused examples so that the concepts stay clear and stable.
- The project checkpoint chapters use the study log application so that the same ideas become part of a working program.
Try not to mix them accidentally. When a chapter explains a for loop or a function definition, focus first on the general idea on the small example. When a project checkpoint returns to the study log, focus on how those ideas fit into the actual project.
Keep Notes on Structure
It is helpful to keep lightweight notes while studying. For example, you might note:
- the main ideas of a chapter,
- a small trace table for a program you found tricky,
- the inputs and outputs of a new function,
- the edge cases you decided mattered for a piece of code,
- or what one section of your project is responsible for.
These notes do not need to be polished. The point is to make your own thinking more visible.
When you are trying to understand how a program runs, what a loop does at each iteration, or where a bug might be hiding, it is often more effective to sketch it on paper than to keep it all in your head or to type it out. A trace table written by hand, or a quick arrow diagram of which variable depends on which, can make the structure much clearer.
Did you know, by the way, that taking notes by hand can help you learn better than typing them on a laptop? It is not just about the drawing. The physical act of writing can help your brain process and remember information more deeply. The research evidence on this is mixed, but many find it helpful. If you have the option, try taking notes by hand for a while and see if it helps you understand the material better.
Coursework and Academic Integrity
The coursework is meant to support your own learning. You may discuss ideas with others, but your submitted work must reflect your own understanding.
Do not publish your solutions publicly or store them in places where other learners can access them directly. This includes finished exercise solutions, project code, and graded reflections.
If you use outside help, the responsibility for the final submitted work still remains yours.
Use of Generative AI
This course takes generative AI seriously. AI coding assistants are now a normal part of writing software, and the course assumes you will sometimes use them. It does not ask you to avoid them, and it does not assume they will write good code for you. Instead, it teaches a set of skills for working with them well.
Across the nine parts, you will develop nine concrete AI-collaboration skills, beginning with reading code carefully (Part 1) and continuing through verifying behavior (Part 2), specifying what you want (Part 3), detecting plausible-but-wrong code (Part 4), and so on. Each of those skills is its own chapter; together they form one of the two main threads of the course.
When using generative AI to support your own studying:
- verify every piece of generated code by reading it and tracing what it does,
- run generated code on more than the obvious input — including edge cases — before trusting it,
- do not submit copied AI-generated solutions as your own work,
- and prefer using AI as a study partner rather than as a replacement for practice.
If you find that you are relying heavily on generative AI, beware the illusion of competence: producing correct results with AI help is not the same as understanding the material yourself. If your understanding is not keeping up, it may be a good idea to slow down and focus on the core materials and exercises without AI support for a while.
The AI-thread chapters across the course are written with the assumption that you have done both: studied without AI sometimes, and studied with it sometimes. Both modes are part of the course.