CptS 464/564 Final Exam Review
December 7; 2011
· More time: about same length as midterm; but 110 minutes not 75
· Not comprehensive! Nothing from first half of class (not directly…) but you might lose a few points if you forget everything you learned in the first half of the class…
· Understand all terms defined.
· Any algorithm/pseudocode you should know (unless per below we are not covering that); don’t in general have to know case studies of actual systems (e.g.; JGroups) but comparing different versions (e.g.; fire alarm app) may help clarify the different programming models
· Do not have to know any specific system/project unless listed below (e.g.; don’t have to know anything on Figure 6.13 at all).
· Any time there is a figure comparing features/characteristics this is absolutely golden to understand completely
· Don’t have to recite/rewrite algorithms; but know how to use them.
· Don’t have to know performance numbers, but the basic conclusions drawn from them
Move 464/564 to spring semesters?
· Advantage: not in student’s first semester in country; for others another semester of experience
· Disadvantage: get one semester later (and the followup advanced class 562/580)
Fits better or worse:
Fall grad courses:
· 527 Computer Security
· 530 Numerical Analysis
· 540 AI
· 542 Graphics
· 553 Graph Theory
· 555 Networks
· 560 Operating Systems
· 561 Architecture
· 562 Fault-Tolerant Computing (even years) or 580 (Advanced Dist Sys)
· 580 Advanced Topics (varies)
Spring grad courses:
· 516 Algorithmics
· 530 Numerical Analysis
· 531 Computational Linear Algebra
· 543 HCI
· 550 Parallel Computation
·
564 Distributed Computing
· 580 Advanced topics (varies)
No need to read any more than the slides here…
· Linda: basic concept of tuple space as an associative memory (plus details in Chap 6.5)
· FT-Linda: different kinds of tuple spaces offered; basics of how implemented
· Jini: nothing testable
· 6.1 Introduction: time and space coupling and uncoupling
· 6.2 Group communication: What it is; value it adds; comparison to IP Multicast and RPC; basic group operations; kinds of groups (closed/open; overlapping/non-overlapping; synchronous/asynchronous); delivery ordering (more in Chap 14); NONE on JGroups example
· 6.3 Publish-subscribe systems: difference from group communication; basic paradigm and programming model; subscription models; implementation issues; implementation choices for content-based routing (CBR);
· 6.4 Message queues: Overall paradigm; compare/contrast with pub-sub and message passing (Chap 4); programming model; implementation issues; NOT JMS or IBM Websphere MQ examples
· 6.5 Shared memory approaches: basic paradigm and programming model (DSM; tuple spaces); Fig 6.27 is very very helpful to really understand…
· 10.1: Introduction: characteristics; compare to IP;
· 10.2: Napster and its legacy: architecture; lessons learned & impact
· 10.3: P2P Middleware: basic capabilities & requirements (functional and non-functional)
· 10.4: Routing overlays: what they are; what they do; NOT details of APIs (Fig 10.4 & 10.5; but main idea of operations);
· 10.5: Overlay case studies: Pastry; Tapestry: compare/contrast; routing algorithms and “costs”; hosts joining and failing/leaving; unstructured P2P: raison d'être; compare/contrast with structured, basic strategies for searching; basics of how Gnutella works.
· 10.6 Application case studies: Squirrel, OceanStore: basic concepts/model for each; Squirrel: only basics per previous, not huge detail; OceanStore: storage organization, basic lookup algorithm; Ivy: compare/contrast with OceanStore, basic architecture
Seminal Lamport paper on logical time (564 only)
· 14.1: Introduction: big picture context
· 14.2: clocks, events, and process states: basic concepts/definitions (slide #3)
· 14.3: skipping (clock synch.)
· 14.4: Logical time and logical clocks: logical time and causality (including table I gave to fill in), lamport clocks, vector clocks
· 14.5: Global states: cuts, DS properties (incl. liveness, safety, timeliness); terms (runs, linearizations) needed later; NOT snapshot algorithm details (only what it does)
· 14.6: Distributed debugging: collecting state; lattices and Lamport orderings and vector clocks; evaluating possibly True and definitely True from a lattice; evaluating consistent cut from vector clocks;
Note: no real need to read anything more than slides, but can read CDKB5 Sec 8.3 if desired.
· CORBA: Basic programming differences between distributed objects and publish-subscribe;CORBA hooks and modules (Slide #30 – review).
· QuO: nothing.
Volunteer(s) for it