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 look at the fundamental building block of computation in functional programming languages, the expression, and build an appropriate model of how expressions “compute”.
We consider a key technique in algorithmic thinking, how one “decomposes” a more complex problem or algorithm into simpler ones.
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 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 whys and hows of working with others.
We explore one of the basic color models used by computers.
We consider how one writes procedures that make decisions.
We continue to consider how one writes procedures that make decisions.
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 return to Scheme’s list data structure and some ways to use lists to work with collections of data.
We explore ways to write procedures without using define (and,
sometimes, without even using lambda). We also consider why
we might do so.
We explore ways to use lists to work with collections of drawings
using “the big three” list procedures: map, reduce, and filter.
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 initial exploration of recursion in Scheme.
We continue to continue our initial exploration of recursion in Scheme.
We explore issues of redundacy in code and mechanisms for reducing such reducancy.
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 expand our understanding of RGB transformations to image transformations.
We return to our first model of images to explore a few more mechanisms for working with with such images and to compare models.
We conside ways to treat images as functions from positions to colors.
After 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 explore pairs, the basic building blocks of lists, and consider other, non-list structures one might build from pairs.
We explore vectors, an alternative to lists for storing data. We consider how data are stored in memory.
We continue to explore vectors.
We consider structures that allow us to store information for quick retrieval.
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 explore patterns of recursion in the design of programs, particularly with regards to higher-order procedures.
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 Scheme’s random procedure and how one might use
that procedure in generating images.
We consider “turtle graphics”, a model of image making originally popularized by the Logo programming language. We also review issues of side effects and program state.
We consider iteration, particularly as it may apply to turtle graphics.
We introduce the final project for the semester.
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.
We provide class time for students to work on their projects.
We consider a common hierarchial mechanism for structuring data and how to realize it in Scheme.
We provide class time for students to work on their projects.
We consider how to write recursive programs that process trees and other tree-like structures.
We dive into a related problem: sorting the elements of a sequence.
Students present their projects
We conclude the course.