← All sample courses
Sample course · full build

Introduction to Computer Science

15 instructional weeks + finals week (Week 1–Week 16) Free sample edition

Built with The Course Maker · samples.thecoursemaker.com

This is a complete course: fifteen instructional weeks and a finals week, every student component, built with The Course Maker and ready to import. Weeks are relative (Week 1 to Week 16); you set the dates when you import it. Browse the whole thing below. Click any piece to read it in full, then click back to return here.

Nothing here is locked behind a signup. The course is the proof.

Free sample edition. No instructor, institution, or term identity appears anywhere in this edition, by design. The syllabus carries fill-in slots (instructor name, contact, office hours, institution policies) for the adopting instructor to make it their own. (Original objectives written from the standard Introduction to Computer Science body of knowledge; not copied from any school's course outline.)
Free sample pack

Download this course

This course is free, complete, and evergreen, and it is yours to keep; free downloads run through June 30, 2028. Students pay $0 for course materials: the readings and videos are links to freely available resources.

Pick the number of instructional weeks in your term; exam weeks sit on top of them. An edition marked “coming soon” is not built yet: asking for it tells us to build it, and we email you when it is ready.

This edition is built, and its download opens soon. Ask for it and we will email you when it is ready.

Get notified when the 15-week pack is ready — by email.

Enter your email address and we will let you know when this edition of the Introduction to Computer Science course is ready to download, as a zip with the course cartridge (.imscc) and the instructor pack. No account and no password.

Use an address you check — the link goes there. Temporary addresses and shared mailboxes such as info@ are not accepted.

We use your address to send the link and, only if you tick the box, occasional messages about this pack. Privacy · Sample Course License

Want this course on your term's calendar and aligned to your institution's course outline and learning outcomes? The Course Maker builds custom editions, each with an alignment report designed to support program review and accreditation. Learn more: thecoursemaker.com

Included in every course

  • ChapterRequired

    Required in every course. Every module presents the same content in three ways — a chapter to read, a slide deck with speaker notes, and captioned videos — so each student can choose how to take it in. The course is designed to reflect UDL's multiple means of representation, and the alignment report describes this to your curriculum committee.

  • Slide deck with speaker notesRequired

    Required in every course. Every module presents the same content in three ways — a slide deck with speaker notes, a chapter to read, and captioned videos — so each student can choose how to take it in. The course is designed to reflect UDL's multiple means of representation, and the alignment report describes this to your curriculum committee.

  • Captioned video linksRequired

    Required in every course. Every module presents the same content in three ways — captioned videos, a chapter to read, and a slide deck with speaker notes — so each student can choose how to take it in. The course is designed to reflect UDL's multiple means of representation, and the alignment report describes this to your curriculum committee. We link videos only when a caption track exists (from the creator or generated automatically), and we never host them.

Like what you see? Build your own.

Give The Course Maker your topic and term dates, approve the plan, and download a complete Canvas course like this one — paced to your calendar and owned by you. $349 founding rate through June 2028 ($499 list).

The syllabus

Policies, schedule, and grading

Read the full course syllabusPolicies, the week-by-week schedule, grading, and the bring-your-own-AI rules, with fill-in slots for the adopting instructor.→
Weighted gradebook

Assignment groups & weights

Configured in the export — the gradebook is set the moment the course is imported.

Assignment groupWeightNotes
Tutorials & Practice10%
Quizzes10%
Workshops20%
Assignments25%
Discussions15%
Exams20%
Total100%Letter Standard
Objectives & outcomes

What students will be able to do

Objective 1

Explain what a program and an algorithm are and how a Python program runs, write and run short programs, trace them line by line to predict their output, and read an error message to tell a syntax error from a runtime exception.

Objective 2

Use variables and the core types int, float, str, and bool; evaluate expressions with correct operator precedence, including true division, floor division, and remainder; convert between types; and read input and build output with indexing, slicing, and f-strings.

Objective 3

Write Boolean expressions with comparison and logical operators, read and build a truth table, and control which code runs with if, elif, and else.

Objective 4

Write while loops and for loops over range(), using counters, accumulators, nested loops, and break, and recognize and repair an infinite loop and an off-by-one error.

Objective 5

Define and call functions with parameters, arguments, and return values, distinguish return from print, and reason correctly about local and global scope.

Objective 6

Choose and use Python's built-in collections (lists, tuples, dictionaries, and sets) with indexing, slicing, mutation, methods, and iteration, and explain aliasing versus copying.

Objective 7

Process text with string methods, read and write files with the with statement, and handle runtime errors with try and except by exception type.

Objective 8

Implement and trace linear search, binary search, and selection sort; describe how an algorithm's step count grows with input size in Big-O terms; write and trace a simple recursive function; and define a class with __init__, attributes, and methods.

SLO A

Program design and implementation: decompose a problem and write, run, and refine a correct Python program using variables, control flow, functions, and collections.

SLO B

Code tracing, testing, and debugging: read a program, predict its output and behavior accurately, and locate and fix its defects.

How this course is built — read this first

Every teaching module carries the same set, in the order a student meets it: a Start Here overview, the chapter (the primary reading), the lecture (titled “Lecture: <module title>”), the slide deck with speaker notes, readings & resources (links only), the lecture tutorial and practice exercises worked with an AI tutor, the quiz, the discussion and the assignment, and the weekly Coding Lab. Exams: the midterm in Week 8 and the final in Week 16, a finals week with no module.

The discussion and the assignment each ship in both formats: the adaptive version is the published, graded item, and its traditional alternative (no AI) is a separate item that ships unpublished beside it. An instructor who prefers the traditional format publishes it and unpublishes or deletes the adaptive one.

What you see here is every student page. The instructor pack (answer keys and worked solutions, rubric calibration, image prompts, audio-brief scripts, and the alignment report) ships only in the download, never on this site.

Adaptive and traditional

Discussions & assignments: both formats in every module

Same learning objective either way; what changes is how the work happens.

Adaptive · published

Work it through with an approved chatbot

The student does the work in a guided conversation with an approved chatbot, using a copy-paste prompt the course provides. For a discussion, the AI is a Socratic partner that challenges their thinking and never writes the post. For an assignment, the AI is a coach: it asks questions, checks the reasoning shown, and waits for the student to revise. The student submits the chat link with the required summary or report.

Traditional alternative (no AI) · unpublished

The familiar way, one click away

The student does the work themselves and submits it, and the instructor grades it against the rubric. No AI required. It ships unpublished, opening with a one-line note to the instructor; publish it instead of the adaptive version if you prefer.

All 16 weeks

Every week, every component

Each week is a heading; every component under it links to the full student page. Week 8 is a teaching module that also carries the midterm bundle; Week 16 is the finals week, with the final exam bundle and no module.

01
Week 1

Introduction to Computing & Computational Thinking

what a program and an algorithm are; an algorithm in plain English before any codehow code runs: the edit, run, read the output, fix loop; the first print statementtracing a program and predicting its output, then confirming by running itreading an error message from its last line: SyntaxError vs. NameError
02
Week 2

Variables, Data Types & Expressions

variables and assignment; reassignment; = puts a value in a namethe core types int, float, str, and bool, and type()arithmetic and operator precedence; / vs. // vs. %; ** binds tightesttype conversion with int(), float(), and str(); the '5' + 3 TypeError
03
Week 3

Input, Output & Strings

input() always returns a string; converting with int() before arithmeticbuilding output with f-strings (concatenation shown once as what they replace)indexing from 0, negative indices, and half-open sliceslen(), IndexError, and why slicing is forgiving while indexing is strict
04
Week 4

Booleans & Conditionals

the bool type and the comparison operatorsand, or, and not; truth tables; not before and before orif, elif, and else; only the first true branch runsthe = vs. == bug and the out-of-order elif chain
05
Week 5

Loops I: The while Loop

the while loop: a condition checked at the top of every passcounters and accumulators; the counter's final value< vs. <= and the off-by-one errorinfinite loops, how to stop one, and break
06
Week 6

Loops II: for, range & Nested Loops

the for loop over a string and over range()range(start, stop, step) and the exclusive stopaccumulating with for; print with endnested loops: grids, tables, and counting lines of output
07
Week 7

Functions

def, parameters, and arguments; defining does not runreturn values and using them; return vs. print; Nonelocal vs. global scope; a plain assignment inside a function makes a localthe three function bugs: no return, printed instead of returned, a local used outside
09
Week 9

Lists

creating, indexing, and slicing lists; a slice is a new listmutation: index assignment, append, insert, pop, remove, sort; what each returnsiterating over a list for a total, an average, and a maximumaliasing vs. copying; is vs. ==; the mutate-while-iterating trap
10
Week 10

Tuples, Dictionaries & Sets

tuples and immutability; unpacking and the one-line swapdictionaries: keys and values, lookup, update, .get(), .items(); KeyErrorthe counting idiom; insertion order as a language guaranteesets for membership and de-duplication; choosing the right collection
11
Week 11

Strings in Depth & Text Processing

string methods: upper, lower, strip, split, join, replace, find, count, startswithimmutability again: a method returns a new string; reassign or nothing changedsplit() makes a list, join() makes a string; parsing a line of textsimple text algorithms: counting words, searching, normalizing, reversing
12
Week 12

File Input/Output & Exceptions

reading and writing files with the with statement; modes 'r' and 'w'reading a file line by line; what read() returnstry and except by exception type; which block runsthe common exceptions and handling a missing file
13
Week 13

Algorithms: Searching, Sorting & Growth

linear search and binary search; the sorted-list preconditioncounting comparisons as a machine-independent measure of workselection sort, pass by passBig-O as the growth class of a step count: constant, logarithmic, linear, quadratic
14
Week 14

Recursion

the base case and the recursive casethe call stack: frames piling up and unwindingfactorial, countdown, and a recursive sum, traced by runningrecursion vs. iteration; a missing base case and RecursionError
15
Week 15

Introduction to Object-Oriented Programming

classes and objects: the blueprint and the instances__init__, attributes on self, and methodseach instance keeps its own statethe missing-self bug; where the course has taken you