\documentstyle{pres}

\basefont{3} % 3 is standard

\me{Matthias Felleisen}

\title{Sample Schedule}

%\newcounter{lec}
%\setcounter{lec}{0}
\newcommand{\lecture}[1]{
 %\refstepcounter{lec}
 %\thelec 
 1 & \multicolumn{2}{l}{#1} \\}
\newcommand{\week}[2]{
 %\refstepcounter{lec}
 %\thelec 
 \multicolumn{2}{c}{#1} & {#2} \\}


\begin{document}

\begin{presentation}
	{useless1}{useless2}
	{
	\xlink{http://www.cs.rice.edu/~matthias}{Matthias Felleisen} 
	}
        {A Guide to Computer Science 210 at Rice}

\begin{slide}{Goals, Student Population}

\slideitem{Goals}
	The primary goal of the course is to expose students to the key
	elements of computer science: 
	\begin{enumerate}
	\item engineering, specifically, the design of artifacts according
		to design rules; 
	\item logic, specifically, reasoning about the behavior of
		artifacts and abstract properties of the behavior; 
	and 
	\item scientific observation, specifically, measuring physical
		properties of computations (duration, memory usage, heat
		generation) or
		psychological properties of human-computer interfaces.
	\end{enumerate}
	The emphasis of the course is on program design and logical 
	reasoning about programs in order to prepare students for the
	second-semester course. 

	The \xlink{http://www.owlnet.rice.edu}{second-semester course}
covers object-oriented program design, basic data structures, and
algorithms. The second course is mostly taught in Java and C++.

\slideitem{Student Population}

	The course assumes {\em no\/} programming background
	but a mastery of basic algebraic ideas. Students with a
	good background in Algebra I tend to perform well,
	independently of their computing experience. 

        Students in {\em computer science\/} and {\em computer
	engineering\/} are required to take the course. The course
	is an elective (1 out of 2) for students in computational 
	and applied mathematics. 

	The actual course population spans the entire range of
	undergraduate majors at Rice, from music to sociology.
	In the past few years (fall 94 through fall 96), music,
	linguistic, sociology, and literature majors without
	any programming background ended in the top five
	percent of the class.

\slideitem{Road Map} 
	The following slides give an overview of the major elements of the
	coure and how they relate to the goals. 

	\xlink{schedule.html}{An accompanying sample schedule}
	explains how to arrange the material into a 14-week
	semester (with approximately 42 lectures).

\end{slide}

\begin{slide}{Principles of Programming and Computing}

\slideitem{What are the Principles of Computing?}  

	Computer scientists study all aspects of programs. They are
	most prominently concerned with the principles of program
	construction (an engineering activity), with methods to
	reason about a program's evaluation (a mathematical or
	logical activity), and with observing physical attributes
	(a scientific activity). Programmers must learn as much as
	possible about these things, if they want to be more than
	mere typists.

\slideitem{What is the Essence of a Program?}
	A simple program (or piece of a program) is a ``box'' that
	consumes and produces information. Consumption and production
	can take many forms: keyboard input, optical, acoustic, etc.
	While the particular form of consumption and production may be
	important for making computers relevant, they are not important
	to understand the essence of a program. We therefore ignore 
	input and output actions and focus instead on the
	representation of information as data and at the description
	of programs as ``rules'' that construct new data from given
	data. 

\slideitem{How about the Computer?}  Once we know how to construct
	such programs, how to determine their logical behavior,
	and how to observe their basic characteristics, we will
	study how a {\em computer\/} represents programs and data
	at the most basic level and how it evaluates programs. The
	two models of computing are quite different. The
	conceptual gap raises a number of questions, all of
	which, in turn, describe the heart of computer science.

\end{slide}

\begin{slide}{Functional Design, Functional Evaluation}

\slideitem{Functional Program Design}

	The fastest and simplest way to teach the principles of
	programming and computing is to teach the design and the
	evaluation of functional programs. 

	Our introduction to functional program design consists of four
	parts: 

	\begin{enumerate}

	\item from information to data and the basic design principles

	\item generative recursion aka divide-and-conquer recursion

	\item accumulator-style programming

	\item functions as first-class values
	\end{enumerate}

\slideitem{Functional Program Evaluation}

	The evaluation of a functional program proceeds according to
	rules that are well-known from Algebra I: the substitution of
	equals for equals and the evaluation of functions for certain
	arguments. To accomodate basic data, like numbers and truth 
	values, we also need the laws for basic arithmetic operations.
	To accommodate compound forms of data (which combine several 
	pieces of information into a single datum), we also need to 
	introduce projection laws. 
\end{slide}

\begin{slide}{Modifying Data}

\slideitem{Imperative Program Design}

	A function cannot remember how often it was called or what
	its previous arguments where. A functional program can only 
	represent physical changes by incorporating time. Both are 
	major impediments to formulating programs in a concise
	manner. 

	To address this problem, the course motivates and covers 
	the design of {\em imperative\/} Scheme programs, especially, 
	\begin{enumerate}

	\item history-tracking programs,

	\item state-reflecting (simulation) programs, and 
	
	\item programs that mutate compound data values,
	especially vectors.  
	\end{enumerate}
\end{slide}

\begin{slide}{The Computer}

\slideitem{The Machine}

	The introduction of a full-fledged machine simulator exposes
	students to the basic ideas of computer architectures. By reading
	the entire program, students get a good idea of how the hardware
	machine is built and how it works. Programming short examples in
	numeric codes gives the students a feeling for the physical model
	of computation underlying hardware.

\slideitem{Programming the Machine}

	The simulator is the starting point for an exploration of
	low-level programming and the history of machine-oriented
	programming languages like assemblers and C. The students
	are introduced to 

	\begin{enumerate} 
	\item the menmonics of assembly language, 

	\item the register allocation of C, 

	\item the ``manual'' allocation of heap memory, and

	\item the basic trade-offs of Scheme, C, and assembly programming.
	\end{enumerate}
\end{slide}

\begin{slide}{Computer Science}

\slideitem{What is Computer Science?}

	The contrast between the physical model of computing and
	the algebraic one raises a number of questions:
	\begin{enumerate} 

	\item Are the two models equivalent?

	\item How are the two models connected? 

	\item How does the need to compute on real hardware affect
	computing?  

	\item Does the abstract model, in the absence of physical
	limitations, pose any limitations on computations? 

	\item What other models of computing are there? Does the
	brain compute?  
	\end{enumerate}
	These questions naturally suggest what the core of the
	computing discipline is about. They also suggest a number
	of lectures on various topics, e.g., the halting problem,
	algoritmica, etc.

\end{slide}

\begin{slide}{The End}


\slideitem{From Functional to OO Design}
	The last week of the course is often dedicated to an
	introduction of object-oriented design principles using
	Java. It shows how object-oriented program design is a 
	a variant of functional design. The segment prepares the
	first part of the second course. 

\begin{center}
\begin{verbsize}{+5}
The End
\end{verbsize}
\end{center}

\end{slide}

\end{presentation}\end{document}