Schedule

The schedule below shows the tentative dates for all class topics, readings, and assignments. You should complete all assigned reading before class on the day it is listed. Labs will be available shortly before the assigned lab day. There may be some revisions to the schedule during the semester, but I will make sure to announce these changes in class.

If you view this page with JavaScript enabled you can jump to the current week on the schedule, and you should see the next day of class highlighted in the schedule below.

Week 1 : Preliminaries
Week 2 : Scheme/Racket basics
M
Jan 31
class 4

Reading and writing procedures

We consider ways to write your own procedures and why you might do so. We also explore how one interprets the algorithms others write. And we develop some mental models for what happens when we run Scheme/Racket programs.

EBoard 04 (Section 1): Defining procedures
EBoard 04 (Section 2): Defining procedures
EBoard 04 (Section 3): Defining procedures

W
Feb 2
class 5

Expressions and types

We explore many of the basic types of values in Racket, the capabilities Racket provides for working with those types, and how one builds more complex expressions. We also continue building our mental model.

EBoard 05 (Section 1): Expressions and Types
EBoard 05 (Section 2): Expressions and Types
EBoard 05 (Section 3): Expressions and Types


Week 4 : Another miscellany
M
Feb 14
class 9

Lists, revisited

We continue our exploration of lists in Racket, including “the big three” list procedures: map, reduce, and filter.

EBoard 09 (Section 1): Lists, Continued
EBoard 09 (Section 2): Lists, Continued
EBoard 09 (Section 3): Lists, Continued

W
Feb 16
class 10

Files and regular expressions

We begin to explore regular expressions, tools used to identify patterns in strings. We also consider files, structures that store data, often for use by other programs.

EBoard 10 (Section 1): Files (and Regular Expressions)
EBoard 10 (Section 2): Files (and Regular Expressions)
EBoard 10 (Section 3): Files (and Regular Expressions)

Th
Feb 17
 
Due
  • Learning Assessments 1

Week 5 : Software design
M
Feb 21
class 12

Introduction to list recursion

We begin our exploration of recursion, the most general form of repetition available in Scheme. You can use recursion to both build and iterate over different kinds of values.

EBoard 12 (Section 1): Recursion
EBoard 12 (Section 2): Recursion
EBoard 12 (Section 3): Recursion

W
Feb 23
class 13

Introduction to list recursion, continued

We continue our introductory exploration of recursion in Racket.

EBoard 13 (Section 1): Recursion Lab
EBoard 13 (Section 2): Recursion Lab
EBoard 13 (Section 3): Recursion Lab

F
Feb 25
class 14

Unofficial Working Differently Day

A day (or at least a class period) for you to not worry about CS.

EBoard 14 (Section 1): Compute Differently Day
EBoard 14 (Section 2): Compute Differently Day
EBoard 14 (Section 3): Compute Differently Day
Reading
  • No reading
Lab
  • No lab
Week 6 : Thinking recursively
Su
Feb 27
 
Due
  • Quiz 5


W
Mar 2
class 16

Local bindings

We consider why and how to name values within procedures.



F
Mar 4
class 17

Documenting and testing your code

We consider documentation for your programs: Why to write documention, when to write documentation, how to write documentation.
We also consider testing: When, why, and how you might test the procedures and programs that you write.

Week 7 : Recursion, continued
Su
Mar 6
 
Due
  • Quiz 6

M
Mar 7
class 18

Recursion over numbers

We consider a slightly different kind of recursion, numeric recursion. In this technique, we once again have procedures call themselves. However, the parameter that we “simplify” at every step is a number, rather than a list.

EBoard 18 (Section 1): Numeric Recursion
EBoard 18 (Section 2): Numeric Recursion
EBoard 18 (Section 3): Numeric Recursion

W
Mar 9
class 19

Randomness

We consider Scheme’s random procedure and how one might use that procedure in generating language.

EBoard 19 (Section 1): Randomness
EBoard 19 (Section 2): Randomness
EBoard 19 (Section 3): Randomness

Th
Mar 10
 
Due
  • Learning Assessments 2

Week 8 : Organizing data
Su
Mar 13
 
Due
  • Quiz 7

M
Mar 14
class 21

Pairs

We explore pairs, the basic building blocks of lists, and consider other, non-list structures one might build from pairs.

EBoard 21 (Section 1): Pairs and Pair Structures
EBoard 21 (Section 2): Pairs and Pair Structures
EBoard 21 (Section 3): Pairs and Pair Structures

W
Mar 16
class 22

Vectors

We explore vectors, an alternative to lists for storing data. We consider how data are stored in memory.

EBoard 22 (Section 1): Vectors
EBoard 22 (Section 2): Vectors
EBoard 22 (Section 3): Vectors

Th
Mar 17
 
Assigned
  • Quiz 8

Spring Break
Week 9 : Abstract data types and data structures

W
Apr 6
class 25

Data abstraction

We build upon the structures we have encountered so far to design our own types and reflect on mechanisms for separating the interface to a type from the implementation of the type.

EBoard 25 (Section 1): Abstract Data Types
EBoard 25 (Section 2): Abstract Data Types
EBoard 25 (Section 3): Abstract Data Types


F
Apr 8
class 26

Structured data

We consider Racket’s techniques for creating structured data types.

EBoard 26 (Section 1): Structured Types
EBoard 26 (Section 2): Structured Types
EBoard 26 (Section 3): Structured Types

Topics: Structured data. Using structs. Mutable and immutable structs.

Week 10 : XML
Su
Apr 10
 
Due
  • Quiz 9

M
Apr 11
class 27

Getting started with HTML and CSS

We begin to consider the content and structure of the course, exploring both our laboratory environment (Linux workstations) and mechansisms for representing and styling text.

EBoard 27 (Section 1): Marking Text
EBoard 27 (Section 2): Marking Text
EBoard 27 (Section 3): Marking Text

Topics: Getting started with Linux. Generalized markup with XML. Web markup with HTML. Page styling with CSS.


W
Apr 13
class 28

Processing XML

We consider how one writes programs that process HTML and XML.

EBoard 28 (Section 1): Marking Text
EBoard 28 (Section 2): Marking Text
EBoard 28 (Section 3): Marking Text

Topics: XML, revisited. Representing XML in Racket. Expressing patterns in XML. Seaching XML. Constructing new documents from old.


Th
Apr 14
 
Due
  • Learning Assessments 3

F
Apr 15
class 29

Transforming XML

We consider additional ways to extract data from XML documents or to transform XML documents into new XML documents.

EBoard 29 (Section 1): Processing and Transforming XML
EBoard 29 (Section 2): Processing and Transforming XML
EBoard 29 (Section 3): Processing and Transforming XML

Topics: Replacing elements. Inserting elements. Deleting elements.

Week 11 : Recursion
Su
Apr 17
 
Due
  • Quiz 10

M
Apr 18
class 30

Higher-order recursive design

We explore patterns of recursion in the design of programs, particularly with regards to higher-order procedures.

EBoard 30 (Section 1): Higher-order recursion
EBoard 30 (Section 2): Higher-order recursion
EBoard 30 (Section 3): Higher-order recursion


Week 12 : Trees
Su
Apr 24
 
Due
  • Quiz 11



F
Apr 29
class 34

Trees

We consider a common hierarchial mechanism for structuring data and its relationship to Scheme/Racket and XML/HTML.

EBoard 34 (Section 1): Trees
EBoard 34 (Section 2): Trees
EBoard 34 (Section 3): Trees
Week 13 : Algorithms
Su
May 1
 
Due
  • Quiz 12

M
May 2
class 35

Project Work Day

We pause to give you an opportunity to work on your projects.

EBoard 35 (Section 1): Project Work Time
EBoard 35 (Section 2): Project Work Time
EBoard 35 (Section 3): Project Work Time
Reading
  • No reading
Lab
  • No lab



F
May 6
class 37

We explore techniques for analyzing the number of calls made in evaluating procedures, particularly recursive procedures. We consider why such analysis is useful. We then delve into a common problem: That of finding values in a collection.

EBoard 37 (Section 1): Algorithm Analysis and Searching
EBoard 37 (Section 2): Algorithm Analysis and Searching
EBoard 37 (Section 3): Algorithm Analysis and Searching
Week 14 : Wrapping up
Su
May 8
 
Due
  • Quiz 13

M
May 9
class 38
Reading
  • No reading
Lab
  • No lab

W
May 11
class 39

Sorting

We explore the problem of sorting. When you sort a list, vector, or other collection, you put the elements in order. The order of the elements usually corresponds to the type of the elements. We might sort strings alphabetically, grades numerically, colors by brightness, and so on and so forth. We also reflect on one common sorting algorithm.

EBoard 39 (Section 1): Sorting algorithms
EBoard 39 (Section 2): Sorting algorithms
EBoard 39 (Section 3): Presentations + Sorting algorithms
Reading
  • No reading
Lab
  • No lab/Discussion day

Th
May 12
 
Due
  • Learning Assessments 4

F
May 13
class 40
Reading
  • No reading
Lab
  • No lab
Finals Week
F
May 20
 
Due
  • Learning Assessments 5
Summer