Schedule
Skip to schedule Week 1  Week 2  Week 3  Week 4  Week 5  Week 6  Week 7  Week 8  Week 9  Week 10  Week 11  Week 12  Week 13  Week 14
Week 0  
#  Day  Date  Topic  Reading(s)  Lab  Work Due  
1  F  8/25 
An introduction to algorithms
We begin the class by exploring the definition of computer science and by trying to write some basic algorithms. 




Week 1  
#  Day  Date  Topic  Reading(s)  Lab  Work Due  
Su  8/27 





2  M  8/28 
Getting started with Linux and Scheme
We begin to consider the content and structure of the course. We also prepare ourselves to use our laboratory environment (that is, the Linux workstations and the DrRacket Programming Environment). 


3  W  8/30 
Basic types
We explore some of the basic types in Scheme and the operations available for those types. 


4  F  9/1 
Introducing lists
We start to explore Scheme’s list data structure and some ways to use lists to work with collections of data. 


Week 2  
#  Day  Date  Topic  Reading(s)  Lab  Work Due  
5  M  9/4 
Writing your own procedures
We consider new ways to write your own procedures and why you might do so. 


T  9/5 





6  W  9/6 
Pair programming
We explore the whys and hows of working with others. We also catch up on any confusing issues from the first few days of class. 



7  F  9/8 
Documenting programs and procedures
We consider documentation for your programs: Why to write documention, when to write documentation, how to write documentation. We also explore the 6P style of documentation that we use in this course. 



Week 3  
#  Day  Date  Topic  Reading(s)  Lab  Work Due  
8  M  9/11 
Testing your procedures
We consider testing: When, why, and how you might test the proceduresand programs that you write. 


T  9/12 





9  W  9/13 
Tables and compound data
We consider how to deal with compound data, such as the title, lattitude, longitude, time, and date of an event. 


10  F  9/15 
Reading lists and tables from files
We consider a variety of techniques for gathering lists and tables of data from files. 


Week 4  
#  Day  Date  Topic  Reading(s)  Lab  Work Due  
11  M  9/18 
Boolean values, predicate procedures, and list filters
We consider a new type and its use in selecting elements from lists. 


T  9/19 





12  W  9/20 
Local bindings
We consider how and why to name values within procedures. 


13  F  9/22 
Conditionals
We consider one of the central components of algorithms. 


Week 5  
#  Day  Date  Topic  Reading(s)  Lab  Work Due  
14  M  9/25 
Discussion of exam 1
We consider your work on exam 1. 




T  9/26 





15  W  9/27 
Displaying data
We explore techniques for displaying simple kinds of data, such as coordinate pairs or counts of categorical data. 


16  F  9/29 
Preconditions, revisited
We revisit preconditions. We then consider programming techniques for ensuring that preconditions are met. 


Week 6  
#  Day  Date  Topic  Reading(s)  Lab  Work Due  
17  M  10/2 
Recursion basics
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. 



T  10/3 





18  W  10/4 
Recursion basics lab
We continue our exploration of recursion basics. 


19  F  10/6 
Recursion with helper procedures
We consider a different form of recursion, one based on the construction of recursive helper procedures that take additional parameters. Along the way, we consider the idea of tail recursion. We also explore how careless design of recursive procedures can inadvertently lead to slow execution. 


Week 7  
#  Day  Date  Topic  Reading(s)  Lab  Work Due  
20  M  10/9 
Other forms of list recursion
We conclude our initial forays into list recursion by looking for some common patterns in the design of recursive procedures. 


T  10/10 





21  W  10/11 
Numeric recursion
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. 


22  F  10/13 
Naming local procedures
We explore how and why one writes local recursive procedures. 


Fall Break  
Week 8  
#  Day  Date  Topic  Reading(s)  Lab  Work Due  
23  M  10/23 
Debugging
We explore techniques for undersatnding and correcting flaws in our programs 


24  W  10/25 
Randomness and simulation
We consider Scheme’s random procedure and how one might use that procedure in writing simple simulations



25  F  10/27 
Pairs and pair structures
We consider pairs, the basic data type used to build lists and other structures in Scheme. We also consider why it is useful to understand about pairs. 


Week 9  
#  Day  Date  Topic  Reading(s)  Lab  Work Due  
26  M  10/30 
Vectors
We consider vectors, an alternative to lists for storing collections of data. 


T  10/31 





27  W  11/1 
Trees
We consider trees, structures built from pairs. Trees are somewhat like twodimensional lists. 


28  F  11/3 
Higherorder procedures, revisited
We revisit the topic of higherorder procedures, one of the most important techniques in languages like Scheme. Higherorder procedures are procedures – like map , leftsection , or compose – that take other procedures as parameters, return other procedures as values, or both.



Week 10  
#  Day  Date  Topic  Reading(s)  Lab  Work Due  
29  M  11/6 
Files in Scheme
We revisit files, considering the lowerlevel operations for working with files, a technique for structuring information that permits the information to persist across invocations of Scheme. Files also let our Scheme programs share information with other programs. 


T  11/7 





30  W  11/8 
Analyzing procedures
We explore techniques for analyzing the number of calls made in evaluating procedures, particularly recursive procedures. We consider why such analysis is useful. 


31  F  11/10 
Project introduction
We introduce the project. 




Week 11  
#  Day  Date  Topic  Reading(s)  Lab  Work Due  
32  M  11/13 
Association lists
We consider association lists, a simple, but useful, technique for organizing tables of information. 


T  11/14 





33  W  11/15 
Binary search
We consider the general problem of searching. We explore binary search, one of the most efficient algorithms for searching. 


34  F  11/17 
Project work day 1
We provide time for groups to work on their projects. 




Week 12  
#  Day  Date  Topic  Reading(s)  Lab  Work Due  
35  M  11/20 
An introduction to sorting
We explore the problem of sorting. When you sort a list, vector, or other collection, you put the elements in order. The order of the elements usually corresponds to the type of the elements. We might sort strings alphabetically, grades numerically, colors by brightness, and so on and so forth. 




36  W  11/22 
Project work day 2
We provide additional time for groups to work on their projects. 




Thanksgiving Break  
Week 13  
#  Day  Date  Topic  Reading(s)  Lab  Work Due  
37  M  11/27 
Insertion Sort
We move from our general exploration of sorting to the implementation of a particular sorting algorithm, insertion sort. We also explore how the running time for that algorithm varies based on the number of values we are sorting. 


T  11/28 





38  W  11/29 
Merge Sort
We continue our exploration of sorting by considering the applicability of the divideandconquer approach to the problem of sorting. We look at one particular divideandconquer algorithm, merge sort. We explore how the running time for that algorithm varies based on the number of values we are sorting. 


39  F  12/1 
Pause for breath
We pause to consider a few final topics 




Week 14  
#  Day  Date  Topic  Reading(s)  Lab  Work Due  
40  M  12/4 
Project presentations
We explore some of your projects. 




T  12/5 





41  W  12/6 
Project presentations
We explore the remaining projects. 




42  F  12/8 
Wrap Up
We conclude the course. 



Finals Week  
#  Day  Date  Topic  Reading(s)  Lab  Work Due  
Th  12/14 
Final Exam (some time this week)



