CSC151 2009F, Class 55: Wrapup

Admin:
* It does my heart good to see so many of you here today.
* If it's Hell Week in Grinnell, and Grinnell just froze over ...
* My need to shovel out from this mess may delay my grading.
* Please fill out the post-course survey 

Overview:
* The subject matter of the course.

CSC 151 has *multiple* subject matters
* Scheme programming
* Programming in general
* Digital art(?)
* Computer science
* Broader lessons
* Anything else that doesn't fit

Scheme programming
* Generally how the language operates
* And how the parts interact
* How to name local values with let
* Named let to do local procedures
* How to document procedures in Scheme
* Scheme is different than anything else
* map
* parenthesization
* Ways to store collections of data in Scheme
  * Lists, vectors, files, trees, ...
* car, cdr, cons
* Lots of basics types: numbers, integers, reals, strings, characters,
  Booleans, lists, vectors, pairs, null, ...
* Conditionals (if, cond, when)
* How to write procedures (with lambda and define)
* Anonymous procedures (with lambda)
* Higher-order procedures (map, section, compose, negate, ...)

Programming in general
* Value of procedures to encapsulate control
  * Write less code
  * Write clearer code (at least if you name your procedures well)
* Need to patch together lots of ideas to solve problems
* We build solutions with prior solutions
  * We always need to start somewhere, with predefined stuff
* There is a danger of needing too big a vocabulary; sometimes
  you're better off mastering a few small things
* The value of documentation
* Higher-order programming: Idea of procedures that use procedures 
  as parameters
* When you've been working on something for an hour (or more) and it
  finally works, it's REALLY SATISFYING!
* Procedures should be robust!
* When you need to write a procedure, look for something similar that
  has been done before
* Divide big problems into smaller problems, solve those, and then
  combine them into a big problem.
* Division between what procedures do and how they do it
  * You can often use them without understanding how
  * But it's better when you do understand how
* Basic tools for building algorithms
  * Basic types and operations
  * Conditionals
  * Loops
  * Procedures
  * The ability to name things

Digital art(?)
* Images are often represented as grids of pixels
* HOG: Higher-order graphics
* Cool algorithmic drawing techniques
  * String art
  * Polar rose
  * Random images
  * And more
* A model of colors and how to combine them
  * And how you might use those to create beauty and use
* Turtles as a model of image drawing
  * A few simple operations can produce very complex and interesting things
* Artists have interesting criteria they apply in examining images
* Images can be art

Computer science
* Recursion as a way of expressing solutions to problems
  * It's cool that you can define something in terms of itself
  * Potentially a broader philosophy
* When looking at an algorithm (or comparing algorithms) it is worthwhile
  to consider the efficiency of the algorithm
  * In terms of the number of steps it takes
* Where CS fits in relation to other sciences
  * Like math, often a tool for the otehr sciences
  * But "it's own thing"
* CS can interact with other disciplines, too
* A discipline where the focus is problem solving, no matter where the
  problem comes
* Programs should be friendly
* Open experimentation in an environment in which you can quickly see
  your results is cool and fun
* Start with a specific solution and then generalize
  * The specific solution will be easier
  * The general solution will be more useful
  * And the specific solution will help you generate the general solution
* Divide and conquer
* Famous algorithms: sequential search, binary search, insertion sort,
  merge sort, ...

Broader lessons
* There is more to life than CS (or than any academic subject) (except whatever you love)
* You learn a lot by talking to other people
  * Talking to other people helps get you out of one perspective 
* Hitting your head against the wall for too long is a bad idea
  (although it feels good when you stop)
* How to work with "different" people
* There's more than one way to solve a problem
* Divide big problems into smaller problems, solve those, and then
  combine them into a big problem.
* Support your fellow classmates
  * You can start to connect with them (and, in general, Grinnellians
    are worth connecting with)
  * In Sam's class, it helps your grade
* We learn in different ways, and often learn better if we see things
  in multiple ways
  * From the reading
  * From discussion
  * From sitting down and doing "simple" problems in class
  * From applying it in more open settings, such as assignments and tests
* DO THE READING BEFORE CLASS
* How to think (BS) on your feet
* Have fun in what you do
* Care about the people around you

Anything else that doesn't fit
* Something things don't fit
* UM can stand for many different things
* Our file server sucks rocks
* It's hard to meet requirements you haven't been given
* The new MediaScheme is much better than the old DrFu
  * It gives useful error messages