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 explore the whys and hows of working with others.
We consider how one writes procedures that make decisions.
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 our exploration of lists through some “finer-grained” operations.
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 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 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 explore issues of redundacy in code and mechanisms for reducing such reducnancy.
We continue our introductory exploration of recursion in Scheme.
We continue to continue our introductory exploration of recursion in Racket.
We pause to reflect on various recursion issues.
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 Scheme’s random procedure and how one might use
that procedure in generating images.
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 consider Racket’s techniques for creating structured data types.
Topics: Structured data. Using structs. Mutable and immutable structs.
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 introduce the final project for the semester.
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.
More class time to work on projects.
Perhaps a space for shifting topics. Perhaps a project work day.
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
We ground our exploration of sorting in some details.
We conclude the course.