Comp210: Principles of Computing and Programming
Fall 2004 -- Exam 1 Need-To-Knows   

This document is constantly being updated--recheck it often!

In no particular order and NOT all inclusive:

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

Last Revised Tuesday, 24-Aug-2004 13:49:15 CDT

©2004 Stephen Wong and Dung Nguyen