Introduction to Computer Science — Syllabus
Introduction to Computer Science is a 3-unit, lower-division undergraduate course offered at [Institution] in [Term]. The class meets in person twice a week for about 75 minutes each time: [Meeting days/times].
This syllabus is the governing document for the course. It tells you what the course is, how your grade is built, what happens each week, and the policies you can count on. Weeks are numbered from Week 1 to Week 16; your instructor's course site gives the due date for each item.
Instructor and Contact
- Instructor: [Instructor name]
- Contact: [Contact info]
- Office hours: [Office hours]
Bring a specific question to office hours, such as a program that prints something you did not predict or an error message whose last line you cannot place, and reach out early: a question asked in the week it comes up is far easier to answer than one saved for exam week. Check the course announcements at the start of each week.
Course Description
This is the first programming course: the gateway course for a computer science major and a common requirement for students in data science, engineering, business, the sciences, and the social sciences. It is taught in Python 3, a widely used first language that is readable and gives quick feedback. No prior programming is assumed. You write and run real code from the first week, and two skills run through every week: tracing, which means reading a program and predicting exactly what it prints, and debugging, which means finding and fixing what is broken. The course's memory hook is that the computer does exactly what you wrote, not what you meant, so the right answer to "what does this print?" is always what Python prints when you run it.
The course moves in a clear arc, each idea making the next one possible. It opens with what a program and an algorithm are, how code runs, and how to read an error message. It then turns to values: variables, types, and expressions, then input, output, and strings. Next come decisions with Booleans and conditionals, repetition with while loops and with for loops over a range, and functions that package a piece of work for reuse, with the midterm as a checkpoint in Week 8. The second half takes up Python's built-in collections (lists, then tuples, dictionaries, and sets), text processing with string methods, reading and writing files and handling errors, searching and sorting with a count of how an algorithm's work grows, recursion, and, as the close, a first class and the objects built from it.
One small program grows with you all term: a reading log with a page goal, a daily pace, and a list of pages read each day. Each week it gains the week's new idea, so you meet a familiar program and a new tool inside it. Around it, the examples come from everyday settings such as receipts, step counters, temperature converters, password checks, to-do lists, word tallies, bike-share counts, campus life, and small games of chance.
This is a first programming course, not a computer-literacy survey, a data-structures course, or a course in object-oriented design. Data structures beyond Python's built-in collections, formal algorithm analysis and proofs, inheritance, regular expressions, and concurrency or networking belong to the follow-on course. Recursion and classes are introduced at a first-course level in Weeks 14 and 15, and the growth of an algorithm's work is read off a counted run, never proved as a theorem.
A note on the discussion weeks
Some weekly discussions ask what code should do when it decides about people. On those questions thoughtful people disagree, and the course presents the strongest case for each position, names the trade-off at stake, and hands the conclusion back to you. A documented fact, such as what a program prints when you run it, is stated plainly and is not treated as a matter of opinion. No company, product, or living person is cast as the example of a failure. The questions include these:
- When should a condition decide about a person? A hard cutoff in an if statement treats everyone the same; it also treats the person one step past the line very differently from the person one step short of it. The trade-off is consistency against fairness, and speed and scale against a person's chance to have a case reviewed.
- Open code or a paid product? Open-source software publishes its source code so anyone can read, change, and share it; proprietary software keeps its code private and is usually sold. The trade-off is openness against pay for the people who build software, and control against outside support.
- How much should a program keep, and when should it run over other people's words? A few lines of Python can count every word in a group's messages or keep a full record of each visitor. The trade-off is usefulness against privacy.
- Fail loudly or fail silently? A program that catches an error and keeps going can stay useful, and it can also hide the one message that would have told you what was wrong. The trade-off is speed and convenience against transparency.
- Who decides the ranking? Whatever a program sorts to the top gets seen or served first. The trade-off is a simple, checkable rule against a mixed rule that may fit people better but is harder to check.
- Who is responsible when software fails? Some place the weight on the people who write the code, others on the people who choose to put it to use or on the people who test it. The trade-off is speed in shipping software against the care it takes to check it.
No grade depends on which view you hold. Your grade depends on stating each side accurately, stating the strongest opposing view charitably before you argue your own, and supporting what you say about a program with what it does when you run it.
Required Materials
You buy no textbook, buy no software, and pay nothing for course materials. Every reading and video is a link to an external resource, opened from the week's page so you always reach the version the course teaches from. Beyond a web browser, you need these free tools:
- A free browser-based Python runner: an online editor that runs Python 3 with no account and nothing to install. You write, run, and fix every program in it.
- Python Tutor at pythontutor.com: a free site that steps through a program one line at a time and draws each variable, list, and function call as it changes.
- The official Python documentation at docs.python.org: the reference the course cites for what each part of the language does.
- A free account with one approved AI chatbot, from the list in the AI-Use Policy below. A free tier is enough for everything in this course, and every AI-based activity also has a route that needs no AI at all.
Learning Outcomes
By the end of this course you will be able to:
- Outcome A. Program design and implementation: decompose a problem and write, run, and refine a correct Python program using variables, control flow, functions, and collections.
- Outcome B. Code tracing, testing, and debugging: read a program, predict its output and behavior accurately, and locate and fix its defects.
The eight course objectives below build toward those two outcomes. Each week's Start Here page names the objective that week serves and turns it into a short checklist of what you should be able to do by the end of the week.
- 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.
- 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.
- Write Boolean expressions with comparison and logical operators, read and build a truth table, and control which code runs with if, elif, and else.
- 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.
- Define and call functions with parameters, arguments, and return values, distinguish return from print, and reason correctly about local and global scope.
- 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.
- Process text with string methods, read and write files with the with statement, and handle runtime errors with try and except by exception type.
- 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.
How this course works
Every module presents the same content in three ways — a chapter to read, a slide deck with speaker notes, and captioned videos — so you can choose how to take it in. Each module's lecture page carries the week's explanation as one spoken-style walk-through as well. Python Tutor gives a fourth way to see a program: one line at a time, as a picture.
A typical week runs in this order:
- Start Here. Open the week's module overview. It lists the week's items in order with time estimates and names the week's checkpoint, the one thing you should be able to do by the end of the week.
- Chapter (about 40 to 55 minutes). The week's primary reading. Read it first, and run each program in it as you go.
- Lecture page and slide deck (about 15 to 20 minutes for the lecture, plus time with the deck). The same ideas, explained aloud and in slides.
- Readings and videos. An optional go-deeper menu; every video has captions.
- Lecture tutorial (60 to 90 minutes). A one-on-one session with your chatbot that teaches, gives practice, and ends with a summary you submit.
- Practice set (about 20 minutes). Ungraded practice with a coach, at your own pace.
- Coding Lab (about 90 minutes). The week's idea put to work by hand: you write, run, and check short programs, fill in a prediction before each run and the actual output after it, or find and fix the bug in a broken program. Then you ask your chatbot for a program or a prediction, run it before you trust it, and catch and correct a slip it makes.
- Discussion (about 45 minutes) and assignment (60 to 90 minutes). Where you put the week's ideas to work on a real question.
- Quiz. A short auto-graded check of what you now know, taken on your own.
Week 8 is lighter: the chapter, lecture, slides, readings, practice set, and discussion, then the study guide, exam-prep tutorial, practice exam, and midterm. Its one piece of new material is the classic-bug checklist: six small slips you read for before you run any program (one equals sign where two belong, the stop a range leaves out and the off-by-one it causes, true division that always gives a float, two strings of digits that join instead of adding, a function with no return that hands back None, and a while loop that never updates). Week 16 has no new module; it holds the final exam and its study guide, practice exam, and exam-prep tutorial.
Grading
Your course grade is the weighted average of the six groups below. The weights sum to 100%.
| Component | Weight |
|---|---|
| Tutorials & Practice | 10% |
| Quizzes | 10% |
| Workshops | 20% |
| Assignments | 25% |
| Discussions | 15% |
| Exams | 20% |
| Total | 100% |
What each group holds
- Tutorials & Practice: the 14 weekly lecture tutorials, 5 points each. The practice sets sit beside them and are ungraded.
- Quizzes: 14 weekly quizzes, 10 points each, in every module except Week 8.
- Workshops: the 14 weekly Coding Labs, 50 points each, in every module except Week 8.
- Assignments: 14 weekly assignments, 100 points each, in every module except Week 8.
- Discussions: 15 weekly discussions, 10 points each, one in every module from Week 1 to Week 15.
- Exams: the midterm in Week 8 (50 points) and the cumulative final in Week 16 (100 points).
Each week's discussion and assignment ship in two versions. The adaptive version is published and graded by default. A traditional version that uses no AI is also in the module, unpublished; your instructor may publish it instead. An unpublished version does not appear to you and does not count. A published traditional version takes the adaptive one's place in the same group, for the same points.
Letter grades follow the standard scheme:
| Letter | Percentage range |
|---|---|
| A | 90–100 |
| B | 80–89 |
| C | 70–79 |
| D | 60–69 |
| F | below 60 |
Weekly Schedule
The course runs for sixteen weeks: fifteen weeks of modules and a finals week. Every module from Week 1 to Week 15 holds the same materials: the Start Here page, the chapter, the lecture page (titled "Lecture:" followed by the module's title), the slide deck, the readings and videos page, and the practice set. Every module also ships both an adaptive discussion and a traditional no-AI alternative, and every module except Week 8 ships both an adaptive assignment and a traditional no-AI alternative. The adaptive versions are graded and published; the traditional alternatives are unpublished by default and count only if your instructor publishes them instead.
| Week | Focus | Lecture page | Graded and published | Traditional alternative (unpublished) |
|---|---|---|---|---|
| 1 | Introduction to Computing & Computational Thinking | Lecture: Introduction to Computing & Computational Thinking | Tutorial, Coding Lab, adaptive discussion, adaptive assignment, quiz | Discussion, assignment |
| 2 | Variables, Data Types & Expressions | Lecture: Variables, Data Types & Expressions | Tutorial, Coding Lab, adaptive discussion, adaptive assignment, quiz | Discussion, assignment |
| 3 | Input, Output & Strings | Lecture: Input, Output & Strings | Tutorial, Coding Lab, adaptive discussion, adaptive assignment, quiz | Discussion, assignment |
| 4 | Booleans & Conditionals | Lecture: Booleans & Conditionals | Tutorial, Coding Lab, adaptive discussion, adaptive assignment, quiz | Discussion, assignment |
| 5 | Loops I: The while Loop | Lecture: Loops I: The while Loop | Tutorial, Coding Lab, adaptive discussion, adaptive assignment, quiz | Discussion, assignment |
| 6 | Loops II: for, range & Nested Loops | Lecture: Loops II: for, range & Nested Loops | Tutorial, Coding Lab, adaptive discussion, adaptive assignment, quiz | Discussion, assignment |
| 7 | Functions | Lecture: Functions | Tutorial, Coding Lab, adaptive discussion, adaptive assignment, quiz | Discussion, assignment |
| 8 | Midterm Review & Exam | Lecture: Midterm Review & Exam | Adaptive discussion, midterm exam | Discussion |
| 9 | Lists | Lecture: Lists | Tutorial, Coding Lab, adaptive discussion, adaptive assignment, quiz | Discussion, assignment |
| 10 | Tuples, Dictionaries & Sets | Lecture: Tuples, Dictionaries & Sets | Tutorial, Coding Lab, adaptive discussion, adaptive assignment, quiz | Discussion, assignment |
| 11 | Strings in Depth & Text Processing | Lecture: Strings in Depth & Text Processing | Tutorial, Coding Lab, adaptive discussion, adaptive assignment, quiz | Discussion, assignment |
| 12 | File Input/Output & Exceptions | Lecture: File Input/Output & Exceptions | Tutorial, Coding Lab, adaptive discussion, adaptive assignment, quiz | Discussion, assignment |
| 13 | Algorithms: Searching, Sorting & Growth | Lecture: Algorithms: Searching, Sorting & Growth | Tutorial, Coding Lab, adaptive discussion, adaptive assignment, quiz | Discussion, assignment |
| 14 | Recursion | Lecture: Recursion | Tutorial, Coding Lab, adaptive discussion, adaptive assignment, quiz | Discussion, assignment |
| 15 | Introduction to Object-Oriented Programming | Lecture: Introduction to Object-Oriented Programming | Tutorial, Coding Lab, adaptive discussion, adaptive assignment, quiz | Discussion, assignment |
| 16 | Finals week (no module) | None | Final exam | None |
The midterm in Week 8 covers Weeks 1 to 7, which is Objectives 1 to 5 as taught in those weeks. The final in Week 16 is cumulative and draws on every course objective: programs, algorithms, tracing, and reading an error message (Objective 1); variables, types, expressions, input, output, and strings (Objective 2); Boolean expressions, truth tables, and conditionals (Objective 3); while and for loops, counters, accumulators, and the off-by-one error (Objective 4); functions, return values, and scope (Objective 5); lists, tuples, dictionaries, and sets, with aliasing versus copying (Objective 6); string methods, files, and exceptions (Objective 7); and searching, sorting, the growth of a step count, recursion, and a first class (Objective 8). Both exams come with a study guide, a practice exam, and an exam-prep tutorial you work with your chatbot.
Attendance and Participation
This course meets in person twice a week. Come to class having opened the week's Start Here page and read the chapter, because class time builds on that reading with programs to predict, run, and fix. Your participation also shows in your weekly work: the tutorial, the Coding Lab, the discussion, the assignment, and the quiz. Each week's programs use the tools taught in the weeks before it (you cannot loop over a list until you can write a loop), so falling a week behind is the most common reason a grade slips; keep to the weekly rhythm and talk to your instructor the moment you feel lost. If you must miss class, follow the week's module from its Start Here page so you stay on pace.
Late Work
Late work loses 10% of the item's points for each day it is late. If something serious comes up, such as an illness or a family emergency, contact your instructor before the due date whenever you can so the two of you can agree on a fair plan. The penalty exists to keep the course moving, not to punish genuine hardship.
Academic Integrity
The work you submit must be your own, and you are bound by your institution's academic integrity standard. Do not copy another student's work, do not submit work you did not do, and do not misrepresent how a piece of work was produced. In a programming course, integrity also means honest output: every output, trace, and error type you report must come from a run you made, and a prediction must be labeled as a prediction. Three violations matter most in this course: reporting an output you did not get by running the code, including one a chatbot predicted; fabricating or doctoring a chatbot conversation or its share link; and using AI on the quizzes, the midterm, or the final. Violations are handled under your institution's academic integrity process and may result in no credit for the item.
Accessibility and Disability
This course is designed to reflect universal-design principles and offers multiple means of representation, engagement, and expression. If you have a disability and need an accommodation, contact your institution's disability services office to arrange it, and let your instructor know so it can be put in place promptly. If any material is hard to use with your assistive technology, tell your instructor and an equivalent version will be provided. Every program a question refers to is shown as text, and every output is written out in words or text as well. This course is not yet accessibility-certified, and your feedback helps improve it. The course page Accessibility & Inclusion in Module 0 explains how the course offers multiple modes, how to turn on captions, and how to request an accommodation.
AI-Use Policy
This course uses an AI chatbot as a study partner and a pair-programmer, and then asks you to run its code before you trust it. Use any one of the approved chatbots: Claude, Gemini, ChatGPT, Grok, or Microsoft Copilot. Your instructor may edit this list. Free tiers are fine, and Copilot is often included with a campus Microsoft 365 account.
AI may be used on these activities:
- Lecture tutorials (completed with a chatbot). Each week you work the tutorial in a conversation with an approved chatbot, then submit the conversation share link and your completion summary.
- Practice sets (ungraded). You work the practice exercises with a chatbot coach.
- Adaptive discussions (completed with a chatbot). You hold a real-time dialogue with an approved chatbot, then post the AI's summary with the conversation share link. This version does not require replies to classmates.
- Adaptive assignments (AI-coached). You work the problems with a chatbot coach that scores your work against the assignment's rubric, then submit the self-scored report and the conversation share link.
- Coding Labs (a required AI-critique step). After your own work, you ask your chatbot for a program or a prediction, run its code, and catch, explain, and correct at least one slip, such as buggy code presented as working, a wrong output prediction, an off-by-one error, invented library or method behavior, or a missed edge case.
- Exam-prep tutorials and studying. Use AI freely to review, to check your understanding, and to prepare for the exams.
AI may not be used on the quizzes, the midterm, and the final. These are closed to AI and must be entirely your own work, because they confirm that you personally can read code, predict what it prints, and find and fix a defect.
A chatbot's prediction is not a run. A chatbot can explain an idea or quiz you on a loop, but it routinely gets operator precedence wrong, drops the decimal from a division result, includes the stop of a slice or a range, claims that a function that prints also returns what it printed, treats a second name for a list as a copy, reports the order of a set with confidence, and miscounts the calls a recursion makes. Every output you submit must come from running the code yourself.
If your instructor publishes a traditional alternative. A traditional discussion is your own post and your own replies to classmates; a traditional assignment is your own submitted work, graded by your instructor. AI may help you think, but you write and submit the work yourself.
Disclosure. The share link documents your AI use on the AI-based activities, so they need no separate note. For any other graded work where AI help is allowed, add one line naming the tool and how you used it.
Bring your own AI: access, cost, and privacy
- Equity and a non-AI route. You never have to create an account with a chatbot company to complete this course or to reach any grade in it. Every AI-based activity in this course carries an Equivalent route (no AI required) on its own page. It assesses the same objectives, for the same points, against the same rubric. Take it whenever you like, for any reason or none; you do not have to ask permission, explain, or arrange it in advance.
- Cost. A free tier of any approved chatbot covers everything in this course. No graded work depends on a paid subscription.
- Privacy. Before you start, read what your chosen chatbot keeps of your conversations and how it uses them. Never paste personal information you would not want stored, such as a real password, your own records, or messages and files that belong to other people, and remember that a share link lets anyone who has it read that conversation.
Built with The Course Maker · samples.thecoursemaker.com