Check back often for updates to our schedule and deadlines.
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 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 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/Scamper programs.
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 using “the big three” list procedures: map, reduce, and filter. We also consider a key technique in algorithmic thinking, how one “decomposes” a
more complex problem or algorithm into simpler ones.
We continue practicing list processing with the “big three.” Additionally, we also take the time to consider good style in programming.
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 explore issues of redundacy in code and mechanisms for reducing such reducnancy.
We consider how to deal with compound data, such as the title, latitude, longitude, time, and date of an event.
We consider a variety of techniques for gathering lists and tables of data from files.
We take a day to review topics and catch up as needed.
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 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.
Continue working on recursion over 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.
Tail recursion – We look at an advanced version of recursion that is ubiquitous in functional programming, tail recursion.
We combine higher-order functions and recursive programming to implement the “big three” operations over lists.
We consider how we might use list recursion to build structures that allow us to store information for quick retrieval.
We consider Scheme’s random procedure and how one might use
that procedure in generating language.
We discuss (finally!) what a side-effect is, why they are useful, and how functional programming (correctly) encourages us to moderate their use.
We explore techniques for displaying simple kinds of data such as coordinate pairs or counts of categorical data.
We kick-off the final project, think about topics, forming groups, and build a plan of action!
We take the whole day to tackle quiz problems
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 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.
CSC-151-01 Wednesday 2-5pm; CSC-151-02 Thursday 2-5pm; CSC-151-03 Wednesday 9am-12pm