First, let's *anticipate*: What *are* parallelism and distributed computing? What might we expect or want in a course on parallel computing or distributed algorithms? Why do them? Decreased elapsed time Distributed input whose mere centralization (convergecast) would be expensive and/or error prone Maintain independence and privacy, yet allowing sharing of *some* precious resources and/or data Other? Typical in study of ``parallel algorithms'': Fast parallel ways to solve problems we already had. (E.g., sorting, as in CLR.) More typical in this course: Ways to solve problems that *first arise* in a parallel/distributed setting. (E.g., broadcast, ``convergecast'', leader election, mutual exclusion.) How compare in difficulty with sequential, centralized computing? Why? New issues: Relative timing: synchronous vs. ``asynchronous'' (vs. other?) Communication: shared memory vs. (msgs. in) network (more realistic) Failures of some of the (possibly many) participants Note the meaning of each, and how much easier the *first* choices should be to deal with: In synchronous operation, local determinism implies global det. (unique executions); but asynchronous operation allows arbitrary clock drifts, requiring us to deal with arbitrary ``interleavings'' of local executions. (Example: mutual exclusion for resource access that is based on outside considerations.) Network communication can require complicated ``choreography'' of data (even worse if it is asynchronous!). *Easiest* combination: synchronized, shared-memory, no faults-- essentially the ``PRAM'' model --mostly untouched in this course! I.e., we'll address more the *difficulties*, rather than the *opportunities*, of parallel/distributed computing.