Schedule

The schedule below shows the tentative dates for all class topics, readings, and major assignments (MPs and SoLAs). You should complete all assigned readings by 10 p.m. on the night before the class in which they are listed. You should complete all lab writeups before the next class session. You can find the full list of due dates on Gradescope.

Due dates for major assignments will not change. However, the particular topics we cover each day may change as we discover that we need more (or less) time on each topic.

If the title of a class session is blue, you should be able to click on it to view the eboard for that class session.

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
M
Jan 22
class 1

An introduction to algorithms

We begin the class by exploring the definition of computer science and by trying to write some basic algorithms.

Reading
  • No reading
Lab
  • No lab


F
Jan 26
class 3

Algorithmic decomposition

We consider a key technique in algorithmic thinking, how one “decomposes” a more complex problem or algorithm into simpler ones.

Week 2 : Fundamentals of Scheme programming
M
Jan 29
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.


W
Jan 31
class 5

Computation via expressions

We look at the fundamental building block of computation in functional programming languages, the expression, and build an appropriate model of how expressions “compute”.


F
Feb 2
class 6

Expressions and types

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

Week 3 : Computing with colors
M
Feb 5
class 7

Characters and strings

We explore the ways in which we represent text in Scheme, including both strings and the characters we use to build strings.

Reading
  • No reading

W
Feb 7
class 8

Week 4 : Controlling computation
M
Feb 12
class 10

Transforming images

We expand our understanding of RGB transformations to image transformations.



F
Feb 16
class 12

Pause for Breath

We pause to catch up on a variety of topics.

Reading
  • No reading
Lab
  • No lab
Due
  • SoLA 1 Post-reflection
  • MP 3 Pre-reflection
  • Quiz 4
Week 5 : Thinking with lists
M
Feb 19
class 13

Another pause for breath

We continue to catch up on topics.

Reading
  • No reading
Lab
  • No lab

W
Feb 21
class 14

Lists

We return to Scheme’s list data structure and some ways to use lists to work with collections of data.


F
Feb 23
class 15

Processing lists

We explore ways to use lists to work with collections of drawings using “the big three” list procedures: map, reduce, and filter. We also consider other ways of processing lists, particularly how we sort lists and tally individual values in lists.

Due
  • MP 3 Post-reflection
  • MP 4 Pre-reflection
  • Quiz 5
Week 6 : A miscellany
M
Feb 26
class 16

Software engineering fundamentals

We consider the trifecta of software engineering: documentation, testing, and debugging. That is, we explore why and how you document your code, why and how you test your code, and how you might find errors in your code.


W
Feb 28
class 17

F
Mar 1
class 18

Ethical considerations in computing

Now that we’ve spent some time exploring various issues in computing, we take a step back and consider problems of ethical computing with seasoned programmer-eyes. As newly-informed citizens, what must we be aware of with respect to ethics in computing?

Lab
  • No lab
Due
  • MP 4 Post-reflection
  • SoLA 2 Pre-reflection
  • Quiz 6
Week 7 : Introducting recursion
M
Mar 4
class 19

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.

Lab
  • No lab
Assigned
  • SoLA 2

W
Mar 6
class 20

Introduction to list recursion, continued

We continue our introductory exploration of recursion in Scheme.


F
Mar 8
class 21

Recursion practice

We continue to continue our introductory exploration of recursion in Racket.

Due
  • SoLA 2 Post-reflection
  • MP 5 Pre-reflection
  • Quiz 7
Week 8 : Expanding our notions of recursion
M
Mar 11
class 22

Local bindings

We explore issues of redundacy in code and mechanisms for reducing such reducnancy.


W
Mar 13
class 23

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.


F
Mar 15
class 24

Pause for breath

We pause to explore and revisit ideas associated with recursion.

Reading
  • No reading
Lab
  • No lab
Due
  • MP 5 Post-reflection
  • Quiz 8
Spring Break
Week 9 : Thinking with data
M
Apr 1
class 25

Randomness

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


W
Apr 3
class 26

Pairs and pair structures

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



F
Apr 5
class 27

Vectors

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

Reading
Due
  • MP 6 Post-reflection
  • SoLA 3 Pre-reflection
  • Quiz 9
Week 10 : More thinking with data
M
Apr 8
class 28

Vectors, continued

We continue to explore vectors.

Reading
  • No reading
Assigned
  • SoLA 3

W
Apr 10
class 29

Dictionaries and hash tables

We consider structures that allow us to store information for quick retrieval.


F
Apr 12
class 30

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.

Due
  • SoLA 3 Post-reflection
  • MP 7 Pre-reflection
  • Quiz 10
Week 11 : A return to recursion
M
Apr 15
class 31

Pause for breath

We pause to reflect on recent topics, particularly the transition from pure functional programming to imperative programming.

Reading
  • No reading
Lab
  • No lab

W
Apr 17
class 32

Higher-order recursive design

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

Assigned
  • Mini-Project 8: Word clouds and other analysis tools

F
Apr 19
class 33

Tail recursion

We continue to stretch our brains with recursive thinking. In particular, We consider tail recursion, an advanced version of recursion that is ubiquitous in functional programming.

Due
  • MP 7 Post-reflection
  • MP 8 Pre-reflection
  • Quiz 11
Week 12 : Binary trees
M
Apr 22
class 34

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.


W
Apr 24
class 35

Project kickoff

We introduce the final project for the semester.

Reading
  • (Mini-)Project 9
Lab
  • No lab
Due
  • Mini-Project 8: Word clouds and other analysis tools
Assigned
  • (Mini-)Project 9

F
Apr 26
class 36

Trees

We consider a common hierarchial mechanism for structuring data and how to realize it in Scheme.

Reading
Due
  • MP 8 Post-reflection
  • MP 9 Pre-reflection
  • Quiz 12
Week 13 : Primarily project time
M
Apr 29
class 37

Tree recursion

We consider how to write recursive programs that process trees and other tree-like structures.


W
May 1
class 38

Sorting out sorting

We dive into an important problem: Arranging the values in a list or vector.

Reading
  • No reading
Lab
  • No lab

F
May 3
class 39

Project work day

We provide class time for students to their projects.

Reading
  • No reading
Lab
  • No lab
Due
  • SoLA 4 Pre-reflection
  • Quiz 13
Week 14 : Wrappping up
Su
May 5
 
Due
  • (Mini-)Project 9

M
May 6
class 40

Case study: sorting

We ground our exploration of sorting in some details.

Lab
  • /labs/sorting.html
Assigned
  • SoLA 4

W
May 8
class 41

Project presentations

Students present their projects

Reading
  • No reading
Lab
  • No lab
Due
  • SoLA 4
  • MP 9 Post-reflection

F
May 10
class 42

Wrapup

We conclude the course.

Reading
  • No reading
Lab
  • No lab
Due
  • SoLA 4 Post-reflection
  • End-of-course evaluation
Finals Week
Tu
May 14
 
Assigned
  • SoLA 5

F
May 17
class 43

All outstanding mini-project redos and learning assessments due by 5pm

The College requires that all work be submitted by 5pm. The only work I will accept at this point will be redos of mini-projects and learning assessments from SoLA 5.

Reading
  • No reading
Lab
  • No lab
Due
  • SoLA 5
Summer