210 Lecture Notes

Announcement:

Schedule

Here's a sample schedule, based on the Spring 2000 class. It roughly describes where the class will go. We will deviate from it (undoubtedly).

Spring 2000 Lecture Notes

These are, literally, the notes from which I lecture. They do not, of course, contain everything said in class. They are not a substitute for attendance.

1. The introductory lecture; includes all sorts of adminstrative detail and advice.
2. Expressions and functions
3. Conditional execution
4. Moving beyond numbers adds data analysis to the design methodology.
5. More complex structures; adds templates to the methodology.
6. Keeping things in lists; introduction to recursive data structures.
7. More Lists; a second lecture on lists, including Scheme's built-in list construct. (Note: the overhead transparency is included in the lecture notes.)
8. Even More Tricks with Lists. We looked at several different ways to build a simple program that manipulated three different (but linked) compound structures and talked about when to decompose the program into several smaller programs. The lecture relied heavily on overhead transparencies that contained the code.
9. Lists of Mixed Data.
10. Recursion and the Natural Numbers.
    This concludes the lecture material that will be covered by the first exam
    
    
11. Family trees, the first time, includes a couple of examples worked in detail.
12. More child-centric family trees, with a side excursion into helper functions.
13. Parent-centric family trees
14. File systems, part I
15. File systems, part II, and functions with two complex arguments
16. Functions with two complex arguments
17. Introducing Local and the slides (Monday, 10/09/2000)
18. Hammering home local (including details on the second exam).
19. Functional Abstraction, part I and the slides
20. Functional Abstraction, part II and the slides
21. Reiterating lambda, plus review for exam
    This concludes the lecture material that will be covered by the second exam
    
    

    ---

    
    
22. Introduction to generative recursion, featuring Hoare's Quicksort and Sierpinski's triangles.
23. Fitting generative recursion into the design methodology, including the generative template, and the 6 questions that you must ask to fill it in.
24. Termination conditions and find-flights. This lecture introduced the problem of finding a path through a graph and used an accumulator to address the termination problem that arose when we added a cyclic path to the graph.
    The slides are essential to following the lecture notes.
25. Finishing up find-flights and looking at reverse. A simpler example with an accumulator.
    For those of you who notice small details, there are no lectures 26 and 27. Item 26 is "lecture 28"
26. Converting to use an accumulator. This lecture shows how to modify the classic list template to handle an accumulator, and runs through the steps required to build an accumulator-based program from scratch.
27. A last look at accumulators. This lecture looks at accumulators on binary trees.
28. Introducting Memo functions. The beginning of a brief sojurn into the world where local, lambda, and define interact to create interesting name spaces. This lecture also introduces set!
29. Memo functions and set!, again This lecture repeats much of the material from the previous lecture.
30. More fun with set! and set-structure!. This lecture explores the use of set! and adds the ability to modify structure elements to the mix.
31. From Data Hiding to Data Abstraction This lecture takes the address book example one step farther, and introduces the notion of data hiding.
32. Finishing up Data Abstraction & Objects This lecture shows how our address book example has evolved into a full-blown object, in the sense of an object-oriented programming language.
33. The Search for Identity. Introduces the distinction between extensional and intensional identity and the Scheme constructs for testing each of them.
34. Vectors. Introduces Scheme's vector construct.
35. Finishing up Vectors. More on vectors.
36. From Programs to Executions, Part I.
37. From Programs to Executions, Part II and the corresponding Scheme code.