►
Description
Aquamarine is the multi-process composition medium based on pi-calculus, designed for distributed applications/backends, both in private deployments and open networks. Aquamarine scripts define the topology of the execution (when and where to move control flow) and data dependency graph (what results and what arguments to pass where), essentially describing the composition of (micro)services, e.g. using one service's output as another service's input. The language primitives are based on pi-calculus operations describing certain topological effects and secured by cryptographic signatures of involved peers. The Aquamarine approach allows building distributed systems of any complexity, effectively expressing network behavior.
A
A
This
experience
is
composed
and
brought
to
the
user.
It's
composed
from
function
calls
functions
is
a
code
which
resides
somewhere.
It
could
be
grouped
into
domain-specific
microservices,
it
may
be
authored
by
different
developers,
and
it
is
running
on
machines
on
certain
peers,
and
these
peers
could
have
different
owners.
They
could
reside
in
different
data
centers.
You
may
be
appear
on
your
own
or
you
can
host
your
own
machine
or
you
can
use
some
shared
resources
and
so
on.
A
So
we
want
to
make
an
open
network
from
these
peers
and
it
means
that
it
needs
to
be
self-coordinated.
The
peers
are
of
the
same
rank.
We
want
to
get
rid
of
gateways
and
controllers,
as
they
make
a
difference,
and
actually
they
constitute
this
security
perimeter
and
disables
the
compatibility
of
microservices
as
they
are
hidden
behind
the
gateway
and
also
want
the
self-coordination
be
efficient.
That
means,
if
we
can
get
rid
of
controllers,
then
we
don't
need
to
have
round
trips
between
service
nodes
and
controllers.
A
Each
node
each
peer
can
take
the
full
responsibility
for
choreographing
itself
for
managing
and
coordinating
itself,
and
to
do
so,
we
want
to
have
recursive
routing,
which
means
that
there
is
no
need
to
send
acknowledge
back
to
the
requesting
node
until
it's
explicitly
stated
that
technology
is
needed.
So
this
is
about
approach,
and
what
we
did
is
echo
marine
is
the
name
of
the
compassibility
medium,
which
is
a
part
of
the
fluence
network.
It's
a
new
language
and
protocol
to
compose
distributed
function,
calls
and
to
enable
open
applications.
A
So
my
main
focus
today
is
the
language,
and
why
do
we
need
the
new
language?
So
the
problem
for
the
language
and
for
the
runtime
for
the
composibility
medium
can
be
stated
as
following.
First
of
all,
you
want
to
call
functions
on
different
peers
and
to
do
so,
you
want
to
describe
how
to
get
from
one
period
to
another
how
the
control
flow
should
should
flow.
So
this
is
about
topology
and
the
network
effect
how
the
control
flow
goes
from
peer
to
peer.
A
Second,
on
every
peer,
we
want
to
run
some
computations
and
we
want
to
use
outputs
from
one
functions
as
inputs
for
another
functions.
They
want
to
do
so
in
a
secure
way.
So
it's
about
data
and
about
the
computational
effect
that
happens
on
a
single
node.
So
at
first,
let's
take
a
look
on
what
happens
on
a
single
pier
how
the
peer
could
approach
it.
So
when
control
flow
is
moved
to
a
single
pier
what
it
can
do,
it
definitely
can
do
all
the
computations
that
could
be
done
locally
and
what
it
cannot
do
locally.
A
A
This
data
is
used
locally
to
produ,
produce
data,
prime,
and
we
also
have
the
code
that
expresses
what
computations
to
perform
on
this
node
and
what
topology
should
be
involved
next.
What
are
the
next
peters
should
take
the
data
prime
and
do
their
job
and
it
looks
like
functional
languages
where
we
have
the
effects
and
data
and
we
can
treat
them
separately.
A
A
We
don't
want
to
reach
conflict
state
of
the
data,
so
data
should
be
conflict-free
replicated
data
type
cdt,
and
this
is
the
invariants
which
are
held
with
the
help
of
a
single
peer
details
of
how
we
get
get
it
are
beyond
of
the
scope
of
this
talk,
but
let's
assume
that
we
just
have
it
then.
Let's
consider
control
flow,
what
it
could
look
like
how
we
could
model
the
network
effects
and
this
moving
of
execution
from
peer-to-peer
desired
properties
for
this
model.
First,
its
simplicity
as
distributed
networks,
are
already
such
a
complicated
topic.
A
It
would
be
nice
not
to
introduce
too
much
complete
complexity
for
network
effects,
so
simplicity
is
a
must,
but
even
having
it
simple,
we
want
to
have
it
flexible
and
we
don't
want
to
introduce
unnecessary
restrictions
on
the
use
cases
and
apologies
which
we
could
use.
And,
finally,
as
we
want
to
have
open
applications
in
a
permissionless
networks,
we
need
to
take
care
of
a
security.
A
At
least
we
need
to
keep
the
invariance
which
were
described
before
and
it's
better
not
to
introduce
too
much
attack
surfaces,
the
network
effects-
and
here
we
have
picalculus
process
calculus.
It's
a
theory
that
expresses
how
the
control
flow,
how
how
the
execution
goes
from
process
to
process
processes
being
either
local
or
network
processes,
and
it
fits
perfectly
for
the
non-deterministic
network
behavior
and
by
the
way
real
world
is
non-deterministic.
A
So
it's
also
nice.
Let's
take
a
look,
how
it
fits
our
desires,
desired
properties.
First
of
all,
p
calculus
is
simple.
This
is
a
the
complete
list
of
operations
that
we
can
do.
We
can
send
a
message.
We
can
receive
a
message
we
can
do
combinators
like
do
subsequent
computations
coproduct
products.
Parallel
computations.
We
have
some
branching
support
with
a
match
and
mismatch.
We
can
introduce
local
names
local
variables
and
we
can
do
replication,
which
means
that
there
are
resources
in
the
network
which
are
not
consumed
with
their
use
like.
A
If
you
call
a
function,
it
doesn't
disappear
after
the
call,
and
thanks
to
the
theory,
we
can
be
sure
that
it
is
enough
enough
for
what
for
flexibility
with
a
big
calculus,
you
can
do
a
lot
of
things.
You
can
describe
very
complex
systems,
starting
with
a
request
response
or
another
control
flow
for
a
single
action
like
a
controller,
or
you
can
do
publisher,
subscriber
broadcast
question
for
a
network
as
a
whole
or
for
a
sub
network,
it's
possible
to
implement
kadam
layer
to
describe
kadamli
and
p
calculus
and
other
eventual
consistent
algorithms.
A
You
even
can
code
and
describe
and
reason
about
strong
consistency
in
terms
of
p
calculus,
so
p
calculus
is
the
foundation
for
coordination,
networks,
development
and
it
doesn't
limit
us
on
a
zone.
I
think
it
is
wonderful
and
finally,
p
calculus
is
secure.
Well,
security
is
not
a
specific
property
of
p
calculus,
but
it
could
be
derived
thanks
to
simplicity
and
a
very
strict
composition
capabilities.
A
So
if
we
have
a
security
considerations
for
all
the
operators
that
they
retain
signatures
on
data
that
there
is
no
way
to
fake
anything
and
so
on,
then
by
induction,
we
can
assume
that
the
complex
scenario
built
from
these
operators
is
also
secure
in
the
same
meaning
of
security,
but
for
the
open
network
it
depends.
It
also
depends
on
the
lower
lower
level
of
security
to
stand.
The
eclipse
attack
and
simple
attack
influence.
A
We
have
a
truss
graph
for
it,
but
it's
also
out
of
scope
of
this
stock,
but
we
have
it
and
that's
the
reasoning
for
eco
marine
ecommerce,
intermediate
representation,
the
low
level
language
that
we
use
to
describe
composition
and
control
flow
between
the
peers
corresponds
to
p.
Calculus
is
just
calculus
put
into
practice:
it's
not
a
complete
list
of
operations
and
we
have
a
match,
mismatch
and
similar
things.
A
You
can
take
a
look
on
it
in
documentation,
but
this
is
the
inspiration
for
air
and
the
main
reason,
and
this
makes
it
possible
to
factor
the
open
application
into
two
stacks.
An
internetworks
stack
which
is
handled
with
echo
marine
and
low
level
representation.
The
code
representation
for
ecommerce
is
air
and
computation
stack
influence
is
handled
with
a
fluence
compute
engine
that
runs
webassembly
and
we
have
the
low
level
representation
of
a
code.
It's
wasm.
A
On
each
node,
that's
about
the
protocol
how
marine
is
processed.
A
current
processing
is
structured
with
a
particles.
Each
particle
contains
some
code,
it's
an
error,
script
and
data.
When
this
particle
comes
to
appear,
all
the
proofs
and
security
guarantees
are
verified
on
the
spear
and
errol
script
is
interpreted
locally
according
to
be
calculus-based
set
of
rules.
A
Services
are
called
within
web
assembly
runtime
on
the
local
node.
This
takes
data
as
input
and
provides
the
modified
data
which
contains
the
new
proofs
for
the
new
outputs.
So
it's
signed
both
inputs
and
outputs
are
signed
by
the
spear
and
finally,
the
particle
is
sent
to
the
next
peers
who
needs
to
process
it,
and
the
next
appears
the
list
of
next
pairs
is
derived
from
the
p
calculus
based
set
of
rules
from
from
the
error
script.
The
question
is:
can
it
be
another
language
why?
Why
error?
Why
not
something
else?