DistrComp Course Overview

1. Distributed Computing is coordinated computing using machines at many locations.
2. It primarily uses message passing.
3. It tries to avoid synchronization.
4. It tries to avoid shared variables.
5. It tries to be robust in the presence of individual machine failures.

1. Semantics of semicolon, parallel-bar, and fat-bar.
2. Review of classic problems in concurrency.
3. Semaphores: weak and strong, split-binary, distributed.
4. Distributed Termination.
5. CSP (Communicating Sequential Processes).
6. GO Language Systems Programming.

1. Distributed Tuple Space and Linda.
2. Clients and Servers, RPC, RMI.
3. Actors, Scala Akka.
4. Distributed file servers. IPFS.
5. Semantics of Concurrency. Axiomatic Semantics. Temporal Logic.
6. Fairness. Starvation. Mutual exclusion. Deadlocks. Livelocks. Interference.

1. Undergraduate course on OS Internals and Concurrent Programming
2. Fluency in C++ and Java; Fluency in Go is not expected.
3. Familiarity with Linux OS and IPC mechanisms.

1. Understand the technologies of Remote Invocation (RPC, RMI), and Actors in several languages.
2. Understand the principles of concurrent, distributed, networked, and parallel computing.
3. Understand non-deterministic computations and unfair scheduling as givens.

1. Write client-server programs using RPC in C/C++, RMI in Java, and Channels in Go, and Actors in Scala.
2. Use distributed file server technology, e.g., IPFS.
3. Reason about programs using assertions and temporal logic.
4. Become fluent in Go and Scala.

1. Gregory R. Andrews, Concurrent Programming: Principles and Practice, Benjamin/Cummings, 1991. {A classic. Look for it on EBay? Text Book.} See also his revision of the above book. ./andrews-multithreaded-toc.html [We will do Chapters 1 and 2 much later in our course.]
2. Alan A. A. Donovan and Brian W. Kernighan. The Go Programming Language. 201x.
3. Andrew S. Tanenbaum and Maaten Van Steen. Distributed Systems: Principles and Paradigms. 201x

1. Course Home Page All course related announcements will be posted on this page.
2. Scala + Akka Documentation, https://doc.akka.io/docs/akka/current/?language=scala
3. Java tutorial, https://docs.oracle.com/javase/tutorial/
4. https://github.com/theanalyst/awesome-distributed-systems "A curated list to learn about distributed systems."

1. Starvation, deadlocks, livelocks. Interference, fairness, safety and liveness properties. Fine-grain and coarse-grain parallelism.
2. Review of classic problems in concurrency.
3. Proper definition of semaphore. Weak and strong semaphores. Split-binary semaphores.
4. Starvation-free mutual exclusion.
5. Readers-Writers and the technique of "passing the baton.''

1. Remote Procedure Calls (RPC), and Clients and Servers.
2. Implementation of RPC. Stub generation, marshaling arbitrary data structures. External data representation (XDR) and RPCGEN. Study of an RPC example.
3. Remote Method Invocation (RMI) and Object Serialization of Java.

1. CSP (Communicating Sequential Processes).
2. Asynchronous and synchronous message passing.
3. Logical clocks, ordering of events.
4. Heartbeat, probe/echo, and broadcast algorithms.
5. Distributed Mutual Exclusion.
6. Implementation of Distributed Semaphores.
7. Distributed Termination Detection.

1. SR: Multiple primitives,
2. Linda: Distributed data structures, and
3. Java, and JavaSpaces,
4. Actors + Akka.
5. Distributed PLs: Erlang, Go, Scala.
6. Distributed File Systems, IPFS

1. Programming logic. Axiomatic Semantics.
2. Assertions on process states.
3. Pre-, post conditions, and loop invariants.
4. Temporal logic.

1. Two exams. Most likely take-home. But, without searching the web or whatever for answers. Honor code expected.

1. https://piazza.com/wright/spring2020/ceg7370/home [Will rename soon.]
2. Piazza is our discussion platform.

1. Projects P0 .. P3 5+10+10+10%
2. P0 src code bundle is given. Show that you can build and run it.
3. P1 in C++, P2 in Java, P3 in Akka. All are extensions of P0.
4. Projects [For full details click this link.]

1. Homework will be given. But neither collected nor graded. Implies that you will work on various things on your own and discuss.
2. Homework for this week, as a sample:
3. Learn the Mine Sweeper game. Imagine each cell is a computer system. A cell talks to neighbors only through message passing. How do we program it?

1. How familiar are you with: critical sections, mutual exclusion, message passing, synchronization, fairness, starvation, non-determinism?
2. Can you differentiate deadlocks from livelocks? safety from liveness?

1. How familiar are you with: Critical Regions, Monitors, binary and general Semaphores?
2. How familiar are you with IPC mechanisms of Linux?

1. How familiar are you with: Producers and Consumers, Readers and Writers, Dining Philosphers, Roll-Your-Own Cigarette Smoking, Sleeping Barber, Drinking Philosophers.

1. How familiar are you with: assertions, pre- post-conditions, loop and class invariants.
2. How familiar are you with: Happened Before?
3. How familiar are you with: Propositions, Predicates and Temporal Logic?

1. How long is the longest C/C++ program that you have written individually?
2. Same question but with Java.
3. Same question but with Scala. (Very possible that you have done nothing with this language.)
4. How familiar are you with make, ant, maven, gradle, and various build-tools?
5. What IDEs have you used and for how long? E.g., idea/ eclipse/ netbeans/ other-IDEs. On Linux? On Windows?

1. Ex: Consider the simple assignment statement
   1. {x := 3 [] 7} (Note the fat-bar)
   2. What is the value of x?
   3. Either 3 or 7; nothing else; but which??
   4. Code better be prepared for either.
2. The above computation P is non-determinant. Each time we run, the result of P may change "for no good reason." Why? Because "non-determinacy" [] is baked in.

1. Fundamentals v Principles v Foundations
2. Concurrency Fundamentals constitute the core of this course.
3. Until the last week of this course, we will use concurrency as a term covering all of networked-, parallel-, and distributed- computing.

1. A semaphore s is an OOP ADT (abstract data type) variable. It has an integer private data member s, only operable with two public methods called P and V, apart from being initialized.
2. P(s) ≡ ‹ await s > 0 → s := s-1 ›
3. V(s) ≡ ‹ s := s+1 ›
4. The complications in the defs are (i) the atomic angular-brackets and (ii) the meaning of await.

1. {semaphore m := 1; P(m); Process-i; V(m)}
2. This is starvation-prone in a distributed context.
3. Designing starvation-free solutions is part of this course.

1. The dots are processes. The thick-rectangles are gates letting in one process at a time. The black rectangle is where we require starve-free mutex. A process finishing this will exit as the black dot did, skipping over the black-, red- and green boundaries.
2. What is the rest of the "idea"?

1. Axiomatics is a way of defining the meaning of PL constructs, in a way much better than English prose.
2. Notationally, we use the triplet < P, S, Q > where P and Q are assertions (True/False Boolexp) on process state, S is a piece of code.
3. Q describes the state after S completed. It assumes that P was true when code S started.
4. P is called a pre-condition. Q is called a post-condition.

1. Here is an example applied to semaphore def.
2. P(s) can be defined as follows: Given [(R and s > 0) ⇒ Q(s, s-1)], we can conclude <R, P(s), Q>
3. V(s) can be defined as follows: Given [R ⇒ Q(s, s+1), we can conclude <R, V(s), Q>
4. There will be considerable discussion on this.

1. RPC Architecture [We will go over this in considerable detail.]

1. How do we send data structures that contain links/addresses to machines across the network?

1. An actor is an extremely light weight process communicating with other actors through mailboxes. No shared variables.

A problem created to illustrate concurrency issues. In our course, we wish to do this in Scala with Akka actors.

1. DFS: A file volume spatially distributed over many machines.
2. Requirements: Transparency, Concurrency, Replication, Heterogeneity, Fault tolerance, Consistency, Security, Efficiency.
3. Fault tolerance == Robustness, 24x7: Immune to (individual) machine failures. cf. CAP "theorem".

1. Inter Planetary File System [Ha ha! For now, only on earth.]
2. https://ipfs.io/ [Do click] "IPFS powers the Distributed Web"
3. Involves Blockchain and Filecoin.
4. Link to Mateti's lectures ../DistFileSys/IPFS/ [Not expected to click today]

1. RevealJS: This presentation was made with https://revealjs.com, a FOSS HTML Presentation Framework
2. Nearly all figures are borrowed from the web