What's Important?

You've written truckloads of LISP code, so it's easy to think of
CS 2360 as a LISP class.  But in reality, we haven't covered that
much material that's specific to LISP programming.  Here's the
a summary of LISP-specific material that you've seen in the past
quarter:

  advantages of LISP over other languages
  function definition (defun) and syntax
  arithmetic operators
  how LISP evaluates an expression
  the list data structure
  first, rest, and cons
  quote
  nil
  cond
  null, atom, numberp, listp
  five (six?) degrees of equality
  member, remove, nthcdr, etc. (see your homework)
  lambda functions
  mapcar, maplist
  apply, funcall
  assoc
  "or" as a switch
  let
  special
  set, setq, setf
  the generalized variable
  dolist, dotimes, do
  special forms
  defmacro
  how LISP really evaluates an expression

On the other hand, we've covered lots of material that's relevant
to the broad spectrum of computer science in general and programming
languages in particular.  Since we used LISP programs as the medium
of information exchange, the global nature of these topics might
not have been obvious, but here's a list of things that we talked
about that are not at all specific to LISP:

  principles, advantages, and disadvantages of
    functional programming
  programming for the benefit of people, not computers
  abstraction, reference, and synthesis
  procedural abstraction
  substitution model of evaluation and how it
    relates to functional programming
  programming without side effects
  abstract data types
  boxes and pointers
  conditionals and predicates
  recursion
  efficiency issues with respect to recursion
  procedures vs. processes
  linear iterative process vs. linear recursive process
  tail recursion vs. augmenting recursion
  multiple recursion
  applicative programming (functions without names),
    passing function bodies as arguments 
  data abstraction
  graphs and directed graphs
  lists and association lists
  trees and tree traversal
  relational networks and network traversal
  depth-first search
  backtracking
  state spaces
  state space search using depth-first search
  heuristics and board evaluation
  state space search using heuristics
  game search or adversarial search
  minimax search
  knowledge representation issues
  variables and scoping
  lexical scoping vs. dynamic scoping
  assignment and its costs
  iteration
  lexical closures (generators)
  static vs. dynamic languages
  building languages on top of languages
  the read-eval(interp)-print loop
  macros and how they work

So if you can talk intelligently and concisely about all these
things, and demonstrate your understanding of these issues by
writing good LISP code, you'll do just fine on the final exam.

And when folks ask you how you did in the LISP class, you can now
correct them and tell them that it wasn't just a LISP class, it
was a COMPUTER SCIENCE class in the truest sense.  



Copyright 1998 by Kurt Eiselt.  All rights reserved.