Comp210 Exam 1 Need-To-Knows
Fall 2002
This document
is constantly being updated--recheck it often!
In no particular order and NOT all inclusive:
- What does it mean to do computing? -- abstract processes on specific information
- General vs. Abstract -- what's the difference?
- Relationship between programs/functions and mathematics.
- First and Second Laws of Computing
- Scheme syntax:
- numbers, symbols, strings
- defining functions
- cond statement
- defining placeholders
- defining, instantiating and accessing structures
- comparing numbers, symbols, strings, structs, lists for equality
- defining functions
- Hand evaluating expressions and functions
- General notion of contracts -- why do we need them? What is their role in
defining a function?
- Why does a function need a purpose?
- Variant vs. Invariant entities. Relationship to abstraction?
- Functions as tools of abstraction. How do functions help express abstraction?
- Encapsulation and its relationship to abstraction. Preservation of encapsulation
and how that manifests itself in your programs.
- Abstraction levels -- how functions are governed by them. What a function
should (not) do with respect to them.
- Data Driven Design
- Design Recipe -- What is it? Remember that it was augmented in Lecture
5! Why are the steps in the order that they are?
- Data definitions -- be able to write them for both concrete and abstract
data structures.
- Design templates -- be able to generate one from your data definition,
especially if the data definition is that of an abstract data structure.
- Compound data structures.
- Inheritance vs. composition as ways of expressing relationships between
data.
- Be able to read and understand simple UML diagrams of inheritance and composition.
- Be able to write functions on compound data structures.
- Lists
- Be able to instantiate and compare 2 for equality.
- Design template for lists.
- Dealing with non-empty lists.
- Recursive algorithms (functions)
- Base case vs Inductive case.-- be able to identify them, as well
as to articulate their differences and importance.
- Relationship of template to recursive algorithms in Scheme.
- Understand why there are pending operations during execution.
- Natural recursion (reverse accumulation) vs. "accumulator-style"
(forward accumulation) algorithms.
- Know the Laws of Scheme
- Mixed data -- why...not?
- Natural numbers -- how to define and process, including templates.
- Be able to write accumulator-style algorithms. Good practice: write the
same algorithm both with forward and reverse accumulation.
- In terms of abstraction, variants, invariant, base cases, inductive cases,
etc, why do we use design recipes and templates?
- Be able to recognize bad code, e.g. code that violates encapsulation and
abstraction levels.
- More coming....