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.