\documentstyle{presn}

\me{Matthias Felleisen}

\title{Sample Schedule}

\newcommand{\lecture}[2]{\slideitem{#1}#2}

\begin{document}

\begin{presentation}
	{useless1}{useless2}
	{\relax}
        {A Sample Schedule for 210}


\begin{slide}{The Parts of the Course}

\slideitem{What is Computing?}

\slideitem{Functional Program Design}

\slideitem{Imperative Program Design}

\slideitem{The Machine}

\slideitem{Programming the Machine}

\slideitem{What is Computer Science?}

\end{slide}
\end{presentation}

\end{document}

\lecture{What are Computers, Programs, and Executions?}{}
  6: Basic Scheme: Expressions, Functions, Evaluations
	from arithmetic to Scheme
	applying the laws of algebra
	core vs Computing knowledge

  9: Lists and List-programming				[assignment 1]
	list of temperature measurements, in Celcius
	is one of them over 100F? 
	Celcius->Fahrenheit is core knowledge, rest is Computing

 11: More List-programming -- Functions are Black Boxes
	letter grades to numeric grades
	computing the grade points of a list of letter grades
	evaluating a function applied to a list
	the design recipe

 13: Rules I: Syntax and Semantics
	processing nested lists: 
	from data description to templates
	syntax rules
	evaluation rules 

 16: Web-programming					[assignment 2]
	finish evaluation rules
	nested self-references
	from data descriptions to templates:
		cons used twice as a constructor -- distinguish
		nested lists (TLS S-expressions)
		family trees

 18: Tree-programming
	from data descriptions to templates:
		family trees
		Web pages -- two pages
	from templates to programs: 
		family trees

 20: Functions of Two Complex Arguments
	a filter function for lists: return lists from function
	family trees: a path to ancestor with same name
	collect all names in a family tree: motivate need for
		2-arg functions

 23: Obscene Programming and Analysis: let		[assignment 3]
	collect all names in a family tree
	discover need for "append" or "merge" two lists
	design recipe for function of two arguments

 25: EXAM 1 "Recursive Functions and Evaluation" -- in class

 27: Managing Data and Programs: define-structure and let
	

OCTOBER
 30: Program Decomposition:				 [assignment 4]
	insertion sort, permutation

  2: Accumulator-style Programs: LOCAL and rules
	sum of prefixes, indexes, 
	how to find out that you need it

  4: Generative Recursion: Gaussian Elimination, Pattern

  7: Generative Recursion:				[assignment 5]
	GCD, SmallestDiv, Quicksort
 11: Functional Abstraction: Patterns
	lesser, greater, equals => filter1
	filter1 => lesser, greater, equals 
	
 14: Functional Abstraction: Mathematical Uses		
	lambda + local => filter2
	predicates as closures (lambda (x) (eq? x Name))
	scalar*, projection => map
	map => scalar*, projection
	sum, product => reduce
	reduce => sum, product, map, filter

 16: Functional Abstraction				
	pragmatics: 
		flexible library functions
		avoid code repetitions
		anticipate future changes 
	mathematical abstractions: 
		numerical differencing
		integrating
		find root 
		
 18: Rules II: Scope and Beta				[assignment 6]

 21: BREAK BREAK BREAK

 23: Functions Aren't Elephants: Remembering History
	elevator controller with two inputs only
	remembering the history of function calls via set!

 25: Time vs State: New Elements vs Changed Elements
	inventory controll
	implementing change of state with set! plus copy
		versus set-bike-location!

 28: Rules, set! vs set-bike-location!, Equality	[assignment 7]
	title, plus definition of intensional 
	and extensionsl equality function

 30: History and State, Graphs
	Discovering Cycles in Graphs

 31: EXAM 2 "Program Design and Evaluation" -- evening
  1: Path in Graph with Cycles -- Again				
??
  4: Imperative Vectors 1				[assignment 8]
	basics
	build-vector, reducing a vector
  6: InClass Exam Appendix
  8: Imperative Vectors 2
	reduce-vector
	affect-vector (fori= ...)

-----------------------------------------------------------------------

 11: Inside the Machine					
	levels of abstraction -- little man was sufficient 
	now it's memory, registers, pc, cpu (bunch of little women)
	evaluating numeric instructions

 13: Machine-level Programming (Assembly, Numeric)	[assignment 9]
	translating simple expressions,
		    if's, simple loops

 15: More assembly level programming

 18: Building a Machine
	explaining the architecture of the machine

 20: C-style Programming in Scheme and C I		[assignment 10]
	from Scheme to C
		basic C concepts -- what they really mean, 
			what they are advertised as 
		recursion to recursion
		tail-recursion to loops
		
 22: C-style Programming in Scheme and C II
		more tail-recursion to loops
		nested loop

-----------------------------------------------------------------------
 25: What is Computer Science?
		Marx and Hegel

 27: C vs Scheme: Implementation/Servics
	C: placeholders versus Scheme: values
	implementing numbers and arithmetic
	implementing vectors and lookups
	Comparing services from languages

DECEMBER
  2: Absolute and Physical Limits
	the halting problem
	the walk through all floating point numbers 
		vs binary search problem
  4: Java I: Formulating Data Descriptions in Java
	list of nums
	family tree
	file system

  6: Java II: Deriving Programs from Data Descriptions
	sum, length on lists
	search name in family tree
	determine size of file system

  9: Java III: History and State in Java
	clases with one object as programs: elevator controller
	elevator with state

 10: EXAM 3 "The Machine and Machine-Oriented Programming" -- evening

 11: Conclusion						[assignment 12]