Summary: This document summarizes the many things I
tried to help you learn in the course. Some, I tried direct methods to
help you learn. Others, I hope you learned indirectly. I've tried
to group these ares from specific to general.
Contents:
You should have learned two languages in this course, Scheme and Java.
Here are some of the details of each language I hope you remember.
- Defining functions and values.
- Simple data types: booleans, numbers, strings, characters.
- Lists as a built-in data type.
- Vectors as a built-in data type.
- File input and output.
- Conditionals.
- Variables and assignment.
- Classes: Fields, contstructors, methods.
- Control: Conditionals, loops, sequencing.
- Error handling with exceptions.
I also hope that you learned more general ideas of ways to approach
problem solving through our coverage of major paradigms.
- Organizing data in lists and vectors.
- Procedures as data and higher-order procedures.
- Particular higher-order procedures: apply, map, operator sections
- Currying
- Symbolic data.
- What is Object-oriented programming?
- How does it relate to procedural and functional programming?
- Modeling using objects (e.g., games, puzzles)
- Inheritance; superclasses; subclasses
- Interfaces
- Polymorphism
- Exceptions (not really OOP, but close)
I hope you learned many general topics in computer science, particularly
with regards to abstract data types and algorithms. Some of these issues
have been covered above, but there are others, too.
- Preconditions and postconditions.
- Carefully specifying problems.
- Recursion as a design technique.
- Separation of interface from implementation.
- Documentation and testing.
- Big O notation (informal and formal).
- Techniques for analyzing iterative algorithms.
- Recurrence relations for analyzing recursive algorithms.
- Recursion as a design technique.
- Divide-and-conquer.
- Greed.
- Dynamic programming.
- Randomness and "Luck" (as in hash tables and Quicksort)
- Searching
- Sequential search.
- Binary search.
- Sorting
- Insertion sort
- Selection sort
- Merge sort
- Heap sort
- Quicksort
- ADTs vs. Data Structures.
- Techniques for designing ADTs.
- Recursion as a design technique for ADTs.
- Implementing using nodes and arrays.
- Lists
- Scheme vs. Nonscheme
- Simple vs. Ordered vs. Sorted
- Linear Structures
- Stacks
- Queues
- Priority queues (and their implementation in heaps)
- Trees
- Binary search trees (and implementing with nodes)
- Heaps (and implementing with arrays)
- Dictionaries
- Association lists
- Sorted lists
- Hash tables
- Binary search trees
Issues not only pertinent to computer science and problem solving.
Skills that will help you as you learn and think.
- Group work (at least for some of you).
- Willingness to take risks.
- Willingness to critique the work of others.
- Ability to think on your feet.
Ways to approach the world.
- You can have fun while doing serious work (or vice versa).
- Grammar and spelling are important and interesting, no matter
what the context.
- Feed people!
When I started college, my mother mentioned that she was thinking
about starting research on the professor as moral model. At the time,
I thought she was silly, as I couldn't recall any professor who had
served as a moral model for me. However, now that I, too, am a professor,
I think my mother is right. Faculty can serve as moral models. Here
are some of the things I hope I modeled for you.
- It is important to treat others as people.
- People are more important than classwork.
- It's okay to admit failings.
Friday, 9 May 2003 [Samuel A. Rebelsky]
;
Check with Bobby