EDX
GTx: CS1301x Introduction to Computing using Python
Course Information
Syllabus
Welcome to CS1301! Readiness Questions; Course Description; Course Assessments
(MOOC); Feedback and Changes (MOOC)
Guide to the Course
Introduction (MOOC); edX; Community; SmartBook; Vocareum
Course Surveys
Start-of-Course Survey
FAQ and Help
FAQ; Getting Help
Unit 1: Introduction to Computing
Chapter 1.1: Computing
Lesson 1: What is Computing?
Lesson 2: Programming Vocabulary
Lesson 3: Programming Languages
Lesson 4: Console vs. GUI
Lesson 5: What is this course?
Lesson 6: Course Outline
Lesson 7: Python
Lesson 8: Setting Up
Lesson 9: Turtles
Chapter 1.2: Programming
Lesson 1: What is Programming?
Lesson 2: Writing Lines of Code
Lesson 3: Writing Code in Python, Part 1 of 2
Lesson 3: Writing Code in Python, Part 2 of 2
Lesson 4: Running Code: Compiling vs. Executing
Lesson 5: Executing Code in Python
Lesson 6: Evaluating Results
Lesson 7: Evaluating Results in Python
Chapter 1.3: Debugging
Lesson 1: What is Debugging?
Lesson 2: Types of Errors
Lesson 3: Types of Errors in Python
Lesson 4: Basic Debugging
Lesson 5: Basic Debugging in Python
Lesson 6: Advanced Debugging
Unit 2: Procedural Programming
Chapter 2.1: Procedural Programming
Lesson 1: What is Procedural Programming?
Lesson 2: Procedural Programming in Python
Lesson 3: Comments and Documentation
Lesson 4: Comments and Documentation in Python
Chapter 2.2: Variables
Lesson 1: What is a Variable?
Lesson 2: Variables in Python
Lesson 3: Assigning Variables
Lesson 4: Assigning Variables in Python
Lesson 5: Data Types
Lesson 6: Data Types in Python
Lesson 7: Type Conversions in Python
Lesson 8: Reserved Keywords in Python
Lesson 9: Dot Notation in Python
Lesson 10: Variables with Turtles
Chapter 2.2 Problem Set
Problem 2.2.1 – 13; Coding Problem 2.2.1 – 4
Chapter 2.3: Logical Operators
Lesson 1: What are Logical Operators?
Lesson 2: Relational Operators
Lesson 3: Relational Operators in Python
Lesson 4: Boolean Operators
Lesson 5: Boolean Operators in Python
Lesson 6: Truth Tables
Chapter 2.3 Problem Set
Problem 2.3.1 – 10; Coding Problem 2.3.1 – 5
Chapter 2.4: Mathematical Operators
Lesson 1: What are Mathematical Operators?
Lesson 2: Mathematical Operators in Python
Lesson 3: Self-Assignment and Incrementing
Lesson 4: Self-Assignment and Incrementing in Python
Lesson 5: Operators Together
Lesson 6: Operators and Context in Python
Lesson 7: Operators and Turtles
Chapter 2.4 Problem Set
Problem 2.4.1 – 10; Coding Problem 2.4.1 – 5
Unit 3: Control Structures
Chapter 3.1: Control Structures
Lesson 1: What are Control Structures?
Lesson 2: The Control Structures: Conditionals, Loops, Functions, and Exceptions
Lesson 3: Indentation and Control Structures in Python
Lesson 4: Scope
Lesson 5: Scope in Python
Chapter 3.2: Conditionals
Lesson 1: What are Conditionals?
Lesson 2: Conditionals in Python
Lesson 3: Conditionals and Operators
Lesson 4: Conditionals and Operators in Python
Lesson 5: Nested Conditionals
Lesson 6: Nested Conditionals in Python
Lesson 7: Conditionals and Scope
Lesson 8: Conditionals and Turtles
Chapter 3.2 Problem Set
Problem 3.2.1 – 11; Coding Problem 3.2.1 – 5
Chapter 3.3: Loops
Lesson 1: What is a Loop?
Lesson 2: Traditional For Loops in Python
Lesson 3: For-Each Loops in Python
Lesson 4: While Loops in Python
Lesson 5: Advanced Loops: Nesting in Python
Lesson 6: Advanced Loops: Keywords and Scope in Python
Lesson 7: Loops and Turtles
Chapter 3.3 Problem Set
Problem 3.3.1 – 6; Coding Problem 3.3.1 – 6
Chapter 3.4: Functions
Lesson 1: What is a Function?
Lesson 2: An Analogy for Functions
Lesson 3: Simple Functions in Python
Lesson 4: Functions with Returns and Parameters in Python
Lesson 5: Common Function Errors in Python
Lesson 6: Advanced Python Functions
Lesson 7: Functions and Turtles
Chapter 3.4 Problem Set
Problem 3.4.1 – 9; Coding Problem 3.4.1 – 6
Chapter 3.5: Error Handling
Lesson 1: What is Exception Handling?
Lesson 2: Try-Catch-Finally
Lesson 3: Try and Except, Part 1 of 2
Lesson 3: Try and Except, Part 2 of 2
Lesson 4: Else and Finally
Lesson 5: Error Handling and Other Control Structures
Lesson 6: Error Handling and Turtles
Chapter 3.5 Problem Set
Problem 3.5.1 – 5; Coding Problem 3.5.1 – 7
Chapter 4.1: Data Structures
Lesson 1: What are Data Structures?
Lesson 2: Passing by Value vs. Passing by Reference
Lesson 3: Passing by Value and Reference in Python
Lesson 4: Mutability in Python
Lesson 5: A Brief Introduction to Methods
Chapter 4.2: Strings
Lesson 1: What are Strings?
Lesson 2: Declaring Strings in Python
Lesson 3: String Concatenation and Slicing in Python, Part 1 of 2
Lesson 3: String Concatenation and Slicing in Python, Part 2 of 2
Lesson 4: String Searching in Python
Lesson 5: Useful String Methods in Python
Lesson 6: Turtles and Text
Chapter 4.2 Problem Set
Problem 4.2.1 – 5; Coding Problem 4.2.1 – 7
Chapter 4.3: Lists
Lesson 1: What are Lists?
Lesson 2: Tuples in Python, Part 1 of 2
Lesson 2: Tuples in Python, Part 2 of 2
Lesson 3: Lists in Python
Lesson 4: Lists, Loops, and Functions, Part 1 of 2
Lesson 4: Lists, Loops, and Functions, Part 2 of 2
Lesson 5: Advanced List-Like Structures
Lesson 6: Lists and Turtles
Chapter 4.3 Problem Set
Problem 4.3.1 – 5; Coding Problem 4.3.1 – 6
Chapter 4.4: File Input and Output
Lesson 1: What is File Input and Output?
Lesson 2: Reading, Writing, and Appending
Lesson 3: Writing Files in Python, Part 1 of 2
Lesson 3: Writing Files in Python, Part 2 of 2
Lesson 4: Reading Files in Python
Lesson 5: Files and Turtles
Chapter 4.4 Problem Set
Problem 4.4.1 – 5; Coding Problem 4.4.1 – 6
Chapter 4.5: Dictionaries
Lesson 1: What is a Dictionary?
Lesson 2: Dictionaries in Python, Part 1 of 3
Lesson 2: Dictionaries in Python, Part 2 of 3
Lesson 2: Dictionaries in Python, Part 3 of 3
Lesson 3: Dictionary Applications
Lesson 4: Dictionaries Applications in Python, Part 1 of 2
Lesson 4: Dictionaries Applications in Python, Part 2 of 2
Lesson 5: Dictionaries and Turtles
Chapter 4.5 Problem Set
Problem 4.5.1 – 4; Coding Problem 4.5.1 – 6
Unit 5: Objects & Algorithms
Chapter 5.1: Objects
Lesson 1: What are Objects?
Lesson 2: Objects and Instances in Python, Part 1 of 2
Lesson 2: Objects and Instances in Python, Part 2 of 2
Lesson 3: Encapsulating Methods in Classes
Lesson 4: Encapsulating Methods in Python, Part 1 of 2
Lesson 4: Encapsulating Methods in Python, Part 2 of 2
Lesson 5: Advanced Topics in Classes in Python, Part 1 of 2
Lesson 5: Advanced Topics in Classes in Python, Part 2 of 2
Lesson 6: Polymorphism and Inheritance and Abstraction, Oh My!
Chapter 5.1 Problem Set
Problem 5.1.1 – 2; Coding Problem 5.1.1 – 6
Chapter 5.2: Algorithms Chapter
Lesson 1: What are Algorithms?
Lesson 2: Complexity and Big O Notation
Lesson 3: Recursion, Part 1 of 2
Lesson 3: Recursion, Part 2 of 2
Lesson 4: Sorting Algorithms, Part 1 of 2
Lesson 4: Sorting Algorithms, Part 2 of 2
Lesson 5: Search Algorithms
Chapter 5.2 Problem Set
Problem 5.2.1 – 4; Coding Problem 5.2.1 – 6
Course Description
This course is an introductory course in computing. It does not presuppose any advanced
knowledge of computer science and requires no more background in math than basic arithmetic. The
class covers the foundations of computing, starting with the fundamental idea of computer programs,
the basics of variables and operators, the control structures for directing program flow, and the data
structures for advanced computing.
Learning Objectives
This course has three high-level learning objectives. At the conclusion of this course, you will
be able to:
Describe and apply the fundamental thought processes and theories of computing.
Write command-line computer programs using fundamental principles of programming.
Apply those abilities to a real target domain.
Course Content
This course is broken into five units:
Unit 1: Computing. In this unit, we'll cover the basics of computing: what it means to write computer
code, how to read computer code, and what it means to run and debug code.
Unit 2: Procedural Programming. In this unit, we'll cover the basic paradigm of programming,
procedural programming. In procedural programming, series of commands are executed in order.
Here, we'll discuss variables, logical operators, and mathematical operators.
Unit 3: Control Structures. In this unit, we'll cover control structures, which are lines of code that
control when other lines of code run. We'll cover conditionals, loops, functions, and error handling.
Unit 4: Data Structures. In this unit, we'll cover how data is structured to be operated upon by a
computer. Specifically, we'll focus on structures that bring together multiple different pieces of data,
like strings, lists, dictionaries, and file input and output.
Unit 5: Advanced Topics. In this unit, we'll preview the next topics in computing: object-oriented
programming and computer algorithms.
Course Structure
Within those units, we have divided the content of this class into three general areas:
Foundations: There exist fundamental principles of programming that span across platforms and
languages. These are taught as general concepts before moving into their implementation in code.
This forms about 30% of our material.
Language: In order to write code, you need a language to write it in. In the language lessons, we'll
take the concepts learned in the foundations lessons and implement them in a specific language (in
this class, Python). This forms about 60% of our material.
Domain: The power of computing is that we can develop programs to actually accomplish real-world
tasks. For the last part of our material, we'll take the concepts we just learned in the given language,
and apply them to a specific domain. In this class, that will be computer graphics and user interfaces.
This forms about 10% of our material.
Each chapter of the course will switch back and forth between foundational material,
language-specific material, and domain-specific material.
Course Assessments (MOOC)
Your grade in this course is derived from three categories: nineteen chapters with their
exercises (50%) and thirteen problem sets (50%). Within each category, each assessment is equally
weighted: each chapter is worth ~2.5%, each problem set is worth 4%.
Exercises: 50%
All nineteen chapters have exercises. Each exercise set is worth ~3% of your grade. These
exercises are meant to be completed while you're learning the material to give you feedback on how
well you're progressing. There are three categories of exercises:
EdX Exercises: these are automatically-evaluated multiple choice and fill-in-the-blank exercises that
are interspersed between many of the lecture videos. You may attempt these as many times as you
need to get the answer right.
Programming Exercises: these are automatically-evaluated programming exercises that are also
interspersed between the lecture videos. These will ask you to write or modify existing code. You can
run the code that you write directly in the browser, and then submit it for instant grading. You may
attempt these as many times as you need to get the answer right.
SmartBook Exercises: these are automatically-evaluated multiple choice and fill-in-the-blank
exercises that are provided through the course's interactive textbook. At the beginning and end of
each chapter, you'll find a link to the corresponding chapter in the SmartBook. You may attempt these
exercises as many times as you need to get full credit.
All three of these types of exercises are lumped together to form your Exercise grade. The
number of exercises in each category will vary from chapter to chapter; you can always check on
your progress on the Progress page. Your SmartBook exercises will typically be the very large
quantity of points listed last for a particular chapter.
Problem Sets: 50%
Thirteen of the nineteen chapters have problem sets (Chapters 1.1, 1.2, 1.3, 2.1, 3.1, and 4.1
do not have problem sets). Each problem set is worth ~4% of your grade.
Like exercises, there are both EdX problems (multiple choice and fill in the blank) and
programming problems (writing and submitting your own code). Problem sets are grouped together
at the end of chapters on the pages marked Problem Set. Note that the EdX problems in problem sets
do not allow unlimited submissions like EdX exercises. Programming exercises still permit unlimited
submissions, however.
You may check on your progress through the problem sets on the Progress page.