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.
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 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 continue our exploration of lists in Scheme, including “the big three” list procedures: map, fold, and filter.
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 the whys and hows of working with others, in particular, the pair programming techniques we use in this course.
We consider Scheme’s random procedure and how one might use
that procedure in generating language.
We introduce the musical composition features of Scamper as well as give a gentle introduction to music theory.
We consider the trifecta of software engineering: documentation, testing, and debugging.
We explore the issue of redundacy in code: why is it bad? How can we use let-bindings to reduce redundancy?
As we close the course, we take a step back from technical material and look at the problem of ethical computing with seasoned programmer-eyes. As newly-informed citizens, what must we be aware of with respect to ethics in computing?
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 how to design recursive functions involving lists.
We continue to explore list recursion by examining how we use recursion to perform basic motions over lists.
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 combine higher-order functions and recursive programming to implement the “big three” operations over lists.
We look at an advanced version of recursion that is ubiquitous in functional programming, tail recursion.
We consider structures that allow us to store information for quick retrieval.
We examine mutable variables in Scheme and how we sequence these effectul operations in our code.
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 introduce the final project for the semester as well as wrap up the labs from this week.
We introduce the final project for the semester as well as wrap up the labs from this week.
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 look at how sound is represented at a low-level in a computer program and how we might manipulate that representation.
We investigate how to construct and manipulate waveforms.
We discuss how we measure the efficiency of code and explore the topic of algorithmic complexity and runtime.
We delve into a common problem: finding elements inside of a collection.
We dive into a related problem: sorting the elements of a sequence.
All groups present their final projects!
We conclude the course with some final thoughts and reflection.