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 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 look at the fundamental building block of computation in functional programming languages, the expression, and build an appropriate model of how expressions “compute”.
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 one of the basic color models used by computers.
We explore the whys and hows of working with others.
We expand our understanding of RGB transformations to image transformations.
We consider how one writes procedures that make decisions.
We pause to catch up on a variety of topics.
We continue to catch up on topics.
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 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 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 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 continue our introductory exploration of recursion in Racket.
We explore issues of redundacy in code and mechanisms for reducing such reducnancy.
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 pause to explore and revisit ideas associated with recursion.
We consider Scheme’s random
procedure and how one might use
that procedure in generating images.
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 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 pause to reflect on recent topics, particularly the transition from pure functional programming to imperative programming.
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 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 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 dive into an important problem: Arranging the values in a list or vector.
We provide class time for students to their projects.
We ground our exploration of sorting in some details.
Students present their projects
We conclude the course.
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.