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.
We begin the class by exploring the definition of computer science and by trying to write some basic algorithms.
We consider Scheme, the programming language we will use throughout the course.
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.
We explore one of the basic color models used by computers.
We take a day off from class to celebrate the value of union labor.
We look at the fundamental building block of computation in functional programming languages, the expression, and build an appropriate model of how expressions “compute”.
We expand our understanding of RGB transformations to image transformations.
We continue our explorations from the previous class.
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.
We explore the ways in which we represent text in Scheme, including both strings and the characters we use to build strings.
We consider how one writes procedures that make decisions.
We pause to reflect on various issues (primarily conditionals).
We explore the whys and hows of working with others.
We return to Scheme’s list data structure and some ways to use lists to work with collections of data.
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.
We continue to explore ways “the big three” and other procedures for manipulating lists of values.
We pause to improve our understanding what we’ve covered in the first five weeks of class, focusing on the basics of creating functions.
We pause to improve our understanding what we’ve covered in the first
five weeks of class, focusing on the “higher order” list functions,
like map, apply, filter, and reduce. We also consider the
interplay between these functions and anonymous functions.
We pause to improve our understanding of what we’ve covered in the first five weeks of class, catching up on any topics left from the previous two review days.
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.
We explore issues of redundacy in code and mechanisms for reducing such reducnancy.
We continue our exploration of lists through some “finer-grained” operations.
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.
We continue our introductory exploration of recursion in Scheme.
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.
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.
We explore pairs, the basic building blocks of lists, and consider other, non-list structures one might build from pairs.
We continue to explore vectors.
We consider structures that allow us to store information for quick retrieval.
We consider Scheme’s random procedure and how one might use
that procedure in generating images.
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.
We consider Racket’s techniques for creating structured data types.
Topics: Structured data. Using structs. Mutable and immutable structs.
We introduce the final project for the semester.
We explore patterns of recursion in the design of programs, particularly with regards to higher-order procedures.
We consider a common hierarchial mechanism for structuring data and how to realize it in Scheme.
We consider how to write recursive programs that process trees and other tree-like structures.
We provide class time for students to their projects.
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.
Students present their projects
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?
We conclude the course.