cs150 Spring 2007

The course is designed to enable students to appreciate, use and understand ideas at the core of computer science. This course covers ideas that will be useful and interesting to students, whether or not they major in computer science.

**Course Description.**
In the past hundred years, computer science has changed the world more
than any other field. Without nuclear Physicists, World War II may have
lasted longer, but without computer scientists the other side may have
won. Without computer science, humans would not have walked on the
Moon, modern medicine would not exist, and Wal-Mart would be a small
store in Arkansas.

But this course is not just about the pragmatic impact of computer
science; it is about how computer science changes the ways we think,
solve problems and understand the world. Despite its name, computer
science has very little to do with the beige boxes we call computers,
and it is far from being a science. It has more in common with music
and mathematics than it does with science or engineering. At its core,
computer science is the study of *imperative knowledge*. Whereas
mathematics is all about declarative knowledge ("what is"), computer
science is all about "how to" knowledge.

Computer science is the study of how to describe and predict properties of information processes. Most of what we know about describing information processes stems from three simple ideas:

- You can define things in terms of themselves (recursive definitions).
- You can treat procedures and data as one and the same (first class procedures).
- When you give something a name, it becomes more useful (abstraction).

The kinds of properties we want to predict about information processes include whether or not there is a procedure that can always solve a given problem (computability), and how much time and space will be required to solve a given problem (complexity).

**Expected Background:** This course is open to students with no
prior background in computer science or programming, but appropriate and
challenging for experienced CS majors also. The only background we
assume is:

- Language: reasonable proficiency in reading and writing English
- Math: understanding of whole numbers and addition, subtraction, multiplication, divison and exponentiation.
- Logic: familiarity with logicial
*and*and*or*and*not*. - Computer Literacy: ability to use email and browse the web.

**Meetings:** Mondays, Wednesdays and Fridays at noon-12:50 pm in
Olsson 005.

**Books:** There is required book for this course:

*Gödel, Escher, Bach: An Eternal Golden Braid*, by Douglas R. Hofstadter (referred to as*GEB*) [Amazon]

A recommended supplemental textbook is:

**Web page:** http://www.cs.virginia.edu/cs150.
This page is updated often and students are expected to visit it
regularly (almost every day). All lectures, notes and assignments for
the course will be posted on the web site.

David Evans (

**Assistant Coaches:**

Kinga Dobolyi

Richard Hsu

Dan Marcus

**Email:** Send mail to *cs150-staff@cs.virginia.edu*
to reach the whole course staff.

The expected problem set due dates and topics (which are subject to change) are:

- Problem Set 1: Problem Solving (Photomosaics), due 22 January
- Problem Set 2: Programming with Data (Poker), due 2 February
- Problem Set 3: Programming with Procedures (Fractals), due 12 February
- Problem Set 4: Review (Cryptography), due 19 February
- Problem Set 5: Programming with State (Economics), due 14 March
- Problem Set 6: Programming with Objects (Narrative), due 26 March
- Problem Set 7: Dynamic Web Sites (Communities), due 4 April
- Problem Set 8: Project (Dynamic Web Site), due 30 April

Unless noted otherwise, problem sets are due at the beginning of class (noon) on the day they are due.

**Quizzes.** There may be several short in-class quizzes throughout
the semester. These may or may not be announced in advance. Except in
unusual circumstances, these will have no effect on your grade.
Instead, they are used to allow you and I to determine if important
concepts have been understood throughout the semester.

**Exams.** There will be two exams during the semester and a final.
All exams will be open book and open notes. All exams will be
take-home unless I have any reason to believe there are any
untrustworthy students in this class.

- Exam 1: out Friday, 23 February, due Monday, 26 February
- Exam 2: out Monday, 16 April, due Friday, 20 April
- Final: out Monday, 30 April, due Monday, 7 May

Students are also encouraged to consult outside sources, including human experts. Always list the resources you used (students, outside experts, papers, web sites) on your submission. The only resource you may not use are CS150 problem sets from previous semesters of CS200. It is to your advantage for the course staff to be able to reuse effective assignments from previous semesters, and important that we can trust you to no abuse those materials.

All students are required to sign the course pledge, which applies to the entire course.

Be able to identify the primitives, means of combination, and means of abstraction for a language; describe a language using BNF or RTN; determine the set of the surface forms in a language described by a BNF grammar or RTN; determine what a surface form in a language means if you are given evaluation rules for the language; determine the value of a Scheme expression following the rules of evaluation.

**Recursive Definitions**

Understand a recursive definition; solve a problem by defining a procedure recursively; reason about the process produced by evaluating an application of a recursively defined procedure; define and understand procedures that take procedures as parameters; define and understand procedures that produces procedures as results.

**Programming with Lists**

Define procedures that manipulate lists, use and understand procedures that traverse lists.

**Programming with Mutation and Objects**

Define and understand procedures that use mutation; draw environment diagrams; explain what environment diagrams mean; define procedures that create objects; explain a class hierarchy; define procedures that use inheritance; explain how a method is selected given class definitions.

**Metalinguistic Abstraction**

Understand an evaluator; modify and evaluator to change the meaning of a language; explain why the difference between eagar and lazy evaluation matters; explain the advantages and disadvantages of static type checking; understand an evaluator that does static type checking.

**Programming for the Internet**

Measure the latency and bandwidth of a network; explain the advantages and disadvantages of packet switching; make a dynamic web site; construct a SQL command to select or insert data in a database table; learn a new language given a BNF grammar and an informal description of its evaluation rules.

**Measuring Complexity**

Describe problems precisely in terms of their inputs and outputs; express the amount of work a procedure requires using Theta notation; describe a problem using O, Omega, Theta; estimate the amount of work a solution to a problem involves; classify problems into complexity classes P and NP; explain convincingly what a problem is in NP; explain what it would mean if someone developed a fast (polynomial time) procedure for an NP-Complete problem.

**Computability**

Explain what it means for an axiomatic system to be perfect, incomplete or inconsistent; explain the essence of Godel's proof; determine if a problem is decidable or undecidable, and provide a convincing (informal) argument why.

**Models of Computation**

Explain how to model computation; understand a finite state machine description and explain what it does; understand a Turing Machine description and explain what it does; explain if a problem can be solved by a finite state machine (or why it cannot); define a Turing Machine that solves a simple problem; reduce a Lambda Calculus term to normal form; create and manipulate Lambda Calculus terms that represent true, false, if, numbers and lists; show that a computing model is (or is not) capable of modeling any mechanical computation.

For students who do not succeed in convincing me they can think like a computer scientist, grades will be based on approximately the following weighting:

Problem Sets | 50 (40-70) |

Exam 1 | 15 (5-15) |

Exam 2 | 15 (10-20) |

Final Exam | 20 (15-50) |

Class Contribution | 0 (0-10) |

Grades will be tabulated varying the weights assigned to each category in several different ways using the ranges above. Some of those weightings will drop the lowest problem set score. In general, the weighting that is best for you is used.

Spend your energy focusing on what you are learning, instead of worrying about your grade. Although the material we cover is challenging, and the pace may seem overwhelming at times, historically all students who put effort into this class have done fine. Although not everyone will succeed, all students are expected to get an A in the course. Students who do outstanding work in the course will be considered for funded summer research positions in Prof. Evans' research group.