A Brief History of Distributed
Programming: RPC
Code Mesh London 2016
Slide 2
Slide 2 text
Christopher Meiklejohn
Université catholique de Louvain
@cmeik
christophermeiklejohn.com
Slide 3
Slide 3 text
Caitie McCaffrey
Distributed Systems Engineer
@caitie
caitiem.com
Slide 4
Slide 4 text
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
How do you communicate
with code running on other
machines?
Slide 8
Slide 8 text
How do you communicate
with code running on other
machines?
We’ve left that as an
exercise for the reader…
Slide 9
Slide 9 text
Erlang
Actor Model
for Concurrency
Transparent
Distribution
Added Later
&
Slide 10
Slide 10 text
Cloud Haskell
Haskell Implementations of Distributed
Erlang semantics
Extension of a Concurrent Language for
Distribution
Slide 11
Slide 11 text
RPC: Remote Procedure Call
make remote calls just as simple a local calls
Slide 12
Slide 12 text
1974 1975 1976
Present
Future
RFC 674 RFC 684 RFC 707
1988
A Critique of the
Remote
Procedure Call
1989
RFC 1094
NFS
1991
CORBA
1994
A Note on
Distributed
Computing
Overview
1984
Implementing
Remote
Procedure Calls
Slide 13
Slide 13 text
Procedure Call
Paradigm (PCP) is an
attempt at defining a
mechanism for
resources sharing
across all 70 nodes
on the Internet.
RFC 674
1974
Slide 14
Slide 14 text
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
Slide 15
Slide 15 text
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
Slide 16
Slide 16 text
1984 Implementing Remote Procedure Calls
First Commercial Grade RPC
Slide 17
Slide 17 text
“We propose the
following test for a
general-purpose
RPC system"
1988
Slide 18
Slide 18 text
“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
Slide 19
Slide 19 text
“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
Slide 20
Slide 20 text
“…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
Slide 21
Slide 21 text
“…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
Slide 22
Slide 22 text
“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
Slide 23
Slide 23 text
“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
Slide 24
Slide 24 text
RFC 1094
First major distributed
filesystem that gained
popularity and adhered
to the existing UNIX
filesystem API
Network File System
1989
Slide 25
Slide 25 text
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
Slide 26
Slide 26 text
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.
Slide 27
Slide 27 text
“It is the thesis of this note
that this unified view of
objects is mistaken”
1994
Slide 28
Slide 28 text
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
Slide 29
Slide 29 text
Two Paths Forward
Treat all
objects as
local
Treat all
objects as
remote
Or
A Note on Distributed Computing
Slide 30
Slide 30 text
“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
Slide 31
Slide 31 text
Present
Slide 32
Slide 32 text
Microservices
Slide 33
Slide 33 text
Microservices
Slide 34
Slide 34 text
Microservices
The Re-emergence of RPC Frameworks
Slide 35
Slide 35 text
Finagle
IDL: Thrift
RPC System for the JVM
Based on Futures
Request/Response
Don’t Provide a Unified Model
Modern RPC Frameworks
Slide 38
Slide 38 text
–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
Slide 39
Slide 39 text
The point of RPC was to make remote
calls just as simple as local calls.
Slide 40
Slide 40 text
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?
Slide 41
Slide 41 text
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?
Slide 42
Slide 42 text
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
Slide 43
Slide 43 text
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