Computation can advance without waiting for all other computations to complete Computation is accomplished via the communication and coordination of networked computers Concurrent Programming Distributed Programming
RFC 684 Criticisms Local Calls & Remote Calls have different Cost Profiles Asynchronous Message Passing is a better model because it makes the passing of messages explicit Remote Calls can be delayed or never return 1975
RFC 707, 1976 RFC 707 1976 A High-Level Framework for Network-Based Resource Sharing Generalization to functions Generalize TELNET and FTP’s call- and-response model to functions from an application-specific grammar. One port for all protocols Control Flow Critique RPC only allows for sequential composition
“Imagine that two programmers are working on a project. Programmer 1 is writing the main program. Programmer 2 is writing a collection of procedures to be called by the main program” A Critique of the Remote Procedure Call Paradigm
“At the very last minute, after all the code has been thoroughly tested, debugged, and documented and both programmers have quit their jobs and left the country …” A Critique of the Remote Procedure Call Paradigm
“…the project management is forced by unexpected, external circumstances to run the program on a distributed system.” A Critique of the Remote Procedure Call Paradigm
“…the project management is forced by unexpected, external circumstances to run the program on a distributed system.” A Critique of the Remote Procedure Call Paradigm
“It is our contention that a large number of thing may now go wrong due to the fact that RPC tries to make remote procedure calls look exactly like local ones, but is unable to do it perfectly” A Critique of the Remote Procedure Call Paradigm
“There is, in fact, no protocol that guarantees that both sides definitely and unambiguously know that the RPC is over in the face of a lossy network.” A Critique of the Remote Procedure Call Paradigm
Network File System Soft Mounting Hard Mounting Introduced new error codes for distributed failures that existing UNIX applications could not handle Operations would block until they could be completed successfully
CORBA Common Object Request Broker Architecture 1991 Supported Cross-Language, Cross Address Space Interoperability for Object-Oriented Programming Interface Definition Language (IDL) : used to generate stubs for remote objects & mappings between different primitive types “It’s Just a Mapping Problem” Remote to local exception mapping, remote to local method invocation.
A Note on Distributed Computing Performance analysis is non-trivial and one design is not always going to be the right design. How do we deal with the problems of pointers and references? Once moved they are no longer valid unless we use distributed shared memory. Failures are detectable in the local environment and result in a “return of control”. In distributed computing this isn’t true. Latency Memory Access Partial Failure
“This approach would also defeat the overall purpose of unifying the object models. The real reason for attempting such a unification is to make distributed computing more like local computing and thus make distributed computing easier. This second approach to unifying the models makes local computing as complex as distributed computing.” Treat all objects as remote A Note on Distributed Computing
–A Note on Distributed Computing “The hard problems in distributed computing are not the problems of getting things on and off the wire.” Kendall et al., “A Note On Distributed Computing”, 1994
The point of RPC was to make remote calls just as simple as local calls. If we treat everything as remote, have we simplified distributed computation at all?
The point of RPC was to make remote calls just as simple as local calls. If we treat everything as remote, have we simplified distributed computation at all? If we can't treat all calls as local, is the *procedure call* the right abstraction for distributed computation?
Future Spores: A Type-Based Foundation for Closures in the Age of Concurrency and Distribution Lasp: Distributed Deterministic Data Flow Programming for Erlang Consistency Analysis in Bloom: a CALM and Collected Approach
Spores Serializable closures with capture controlled by the type system (Scala) Dual to Actor Systems (like Erlang). Actors exchange data with async messaging, spores are stateless processes that pass functions around with asynchronous messages Spores are small units of possibly mobile functional behavior
caitiem20
minorun365
coconala_engineer
yoshimi0227
sat
picardparis
pkshadeck
takanorig
aoshun7
toshi0383
dahatake
leveragestech
you
schacon
robhawkes
speakerdeck
jensimmons
marktimemedia
afnizarnur
cherdarchuk
vanstee
addyosmani
michaelherold
sachag
marcelosomers