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.
EBoard 01 (Section 1): Getting StartedWe consider Racket, the programming language we will use throughout the course.
EBoard 02 (Section 1): The Lab Equipment (aka MathLAN and DrRacket)We consider a key technique in algorithmic thinking, how one “decomposes” a more complex problem or algorithm into simpler ones.
EBoard 03 (Section 1): Images and DecompositionWe 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.
EBoard 04 (Section 1): Defining proceduresWe explore many of the basic types of values in Racket, the capabilities Racket provides for working with those types, and how one builds more complex expressions. We also continue building our mental model.
EBoard 05 (Section 1): Expressions and TypesWe consider how one writes procedures that make decisions.
EBoard 06 (Section 1): ConditionalsWe explore the whys and hows of working with others.
EBoard 07 (Section 1): Pair ProgrammingWe return to Scheme’s list data structure and some ways to use lists to work with collections of data.
EBoard 08 (Section 1): ListsWe continue our exploration of lists in Racket, including “the big three” list procedures: map, reduce, and filter.
EBoard 09 (Section 1): Lists, ContinuedWe begin to explore regular expressions, tools used to identify patterns in strings. We also consider files, structures that store data, often for use by other programs.
EBoard 10 (Section 1): Files (and Regular Expressions)We continue our exploration of regular expressions and files.
EBoard 11 (Section 1): Regular ExpressionsWe 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.
EBoard 12 (Section 1): RecursionWe continue our introductory exploration of recursion in Racket.
EBoard 13 (Section 1): Recursion LabA day (or at least a class period) for you to not worry about CS.
EBoard 14 (Section 1): Compute Differently DayWe continue to continue our introductory exploration of recursion in Racket.
EBoard 15 (Section 1): Recursion, ContinuedWe consider why and how to name values within procedures.
We consider documentation for your programs: Why to write
documention, when to write documentation, how to write
documentation.
We also consider testing: When, why, and how you might test the
procedures and programs that you write.
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.
EBoard 18 (Section 1): Numeric RecursionWe consider Scheme’s random
procedure and how one might use
that procedure in generating language.
We pause to discuss a variety of issues.
EBoard 20 (Section 1): Pause for BreathWe explore pairs, the basic building blocks of lists, and consider other, non-list structures one might build from pairs.
EBoard 21 (Section 1): Pairs and Pair StructuresWe explore vectors, an alternative to lists for storing data. We consider how data are stored in memory.
EBoard 22 (Section 1): VectorsWe continue to explore vectors.
EBoard 23 (Section 1): Vectors, ContinuedWe consider structures that allow us to store information for quick retrieval.
EBoard 24 (Section 1): Dictionaries, Maps, and Hash TablesWe 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.
EBoard 25 (Section 1): Abstract Data TypesWe consider Racket’s techniques for creating structured data types.
EBoard 26 (Section 1): Structured TypesTopics: Structured data. Using structs. Mutable and immutable structs.
We begin to consider the content and structure of the course, exploring both our laboratory environment (Linux workstations) and mechansisms for representing and styling text.
EBoard 27 (Section 1): Marking TextTopics: Getting started with Linux. Generalized markup with XML. Web markup with HTML. Page styling with CSS.
We consider how one writes programs that process HTML and XML.
EBoard 28 (Section 1): Marking TextTopics: XML, revisited. Representing XML in Racket. Expressing patterns in XML. Seaching XML. Constructing new documents from old.
We consider additional ways to extract data from XML documents or to transform XML documents into new XML documents.
EBoard 29 (Section 1): Processing and Transforming XMLTopics: Replacing elements. Inserting elements. Deleting elements.
We explore patterns of recursion in the design of programs, particularly with regards to higher-order procedures.
EBoard 30 (Section 1): Higher-order recursionWe prepare to undertake an individually designed project.
EBoard 32 (Section 1): Project kickoffWe get our brains back working on recursion
EBoard 33 (Section 1): Tail RecursionWe consider a common hierarchial mechanism for structuring data and its relationship to Scheme/Racket and XML/HTML.
EBoard 34 (Section 1): TreesWe pause to give you an opportunity to work on your projects.
EBoard 35 (Section 1): Project Work TimeWe consider how to write recursive programs that process trees and other tree-like structures.
EBoard 36 (Section 1): Tree Recursion and Binary Search TreesWe 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.
EBoard 37 (Section 1): Algorithm Analysis and SearchingStudents present their projects
EBoard 38 (Section 1): Project PresentationsWe 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. We also reflect on one common sorting algorithm.
EBoard 39 (Section 1): Sorting algorithmsWe conclude the course.
EBoard 40 (Section 1): Wrapup