►
From YouTube: Programming Distributed Systems with Aquamarine
Description
Speaker: Bernhard Borges, Fluence Labs
Timecodes:
00:00 Intro
00:14 Fluence Labs. Peer-to-peer infrastructure.
02:21 The need for distributed programming tools. How the Request-Response differs from client-server and peer-to-peer application
04:29 Aquamarine programming language
06:48 Aquamarine foundations: inspired by π-calculus
07:56 Aquamarine foundations: particle — data structures combining data, execution, sequence, and metadata
08:12 Aquamarine Instructions, Aquamarine Intermediary Representation, low-level Aquamarine language
10:07 Particle — data structure combining data, execution, sequence, and metadata
11:21 Aquamarine VM + Aquamarine Languages
14:23 Building with Aquamarine
16:00 Aquamarine in Action: Basic SEQ (iterate over results "manually")
18:17 Fold SEQ (iterate programmatically)
21:59 Security
24:37 Greeting app example
26:35 "fldist" Aquamarine tool
33:09 Recap
34:59 Q&A: Is there a way to trace the routing path which a particle took? How do we debug what went wrong?
38:56 Q&A: Could you elaborate on fault tolerance and error handling within scripts with XOR operation and %last_error%?
42:03 Aquamarine from the problem-solving perspective
50:40 Q&A: How do we maintain latency SLA’s? can we have strict performance characteristics for each peer in the network?
Greeting app:
https://github.com/fluencelabs/examples/tree/main/par-greeter
Get started with Fluence https://fluence.gitbook.io/docs/
Protocol Paper https://github.com/fluencelabs/rfcs/blob/main/0-overview.md
Dashboard https://dash.fluence.dev/
Github https://github.com/fluencelabs
Fluence Home https://fluence.network/
A
All
right,
so
the
the
topic
of
today's
talk
is
programming
is
distributed
systems
with
aquamarine,
and
I
know
this
is
not
the
title
you
were
promised,
but
believe
me,
it's
a
very
worthy
bait
and
switch.
So
I
hope
you
will
not
be
disappointed
before
we
go
into
act,
marine
and
and
the
way
to
program
distributed
systems,
especially
peer-to-peer
systems.
Let
me
just
tell
you
a
little
bit
about
fluence
labs.
A
Programming
tooling,
like
lit
p2p,
but
if
you've
ever
tried
to
put
on
top
of
peer-to-peer
protocols
you,
you
know
it's
still
extremely
frustrating
and
very
very
challenging,
and
that's
really
where
fluence
comes
in,
with
our
with
our
ecosystem,
almost
to
to
support
developers
to
make
it
easier
to
accelerate
the
build
out
and
really
make
it
a
much
more
enjoyable
experience
to
to
build
on
peer-to-peer
and
that's
why
we
actually
created
aquamarine
and
aquamarine
is
a
runtime
in
programming
language.
Actually,
it's
two
programming
languages
we'll
get
to
that.
A
One
of
the
reasons
why
we
are
focused
on
peer-to-peer
is
peer-to-peer
is
pretty
much
the
only
way
to
avoid
central
to
censorship
and-
and
that
comes
from
centralized
systems-
and
this
is
this
is
not
just
from
political
perspective.
It's
increasingly
from
a
business
perspective,
as
you
probably
all
have
heard.
A
And
one
of
the
reasons
is
that
if
you
look
at
the
traditional
request
response
pairing
processed
by
client
server
applications,
let's
just
say
you-
you
want
to
get
a
stripe
authorization
and
then
you
want
to
send
an
sms
to
the
user,
to
inform
of
the
authorization
process
outcome
and
so
usually
what
you
do
is
you
send
your
request
to
strive?
You
get
a
response,
then
you
turn
around
and
send
the
response
to.
I
don't
know
io
and
they
send
the
sms
and
you're
all
good
to
go.
A
So
in
many
respects
your
client,
your
your
application,
handles
an
end-to-end
request.
Response
calls
that's
expensive,
not
just
from
a
traffic
perspective,
but
from
the
from
the
resources
required
to
host
or
or
run
that
application
peer-to-peer
networks
allow
you
to
approach
this
a
little
bit
differently
and
much
more
effectively,
and
basically,
what
it
allows
you
to
do
is
it
allows
you
to
take
the
response
from
a
service?
A
A
A
A
It
is
comprised
of
a
low-level
language,
air
aquamarine,
intermediate
representation,
which
we
will
be
looking
at
today
and
that
low-level
language
is
actually
intended
to
be
a
compilation
target,
but
that's
the
first
one
we
had
and
our
aqua
our
high
level
language,
which
is
super
ergonomic.
You'll
you'll,
really
love
it,
but
as
I'm
advertising
it,
it's
not
quite
ready.
It
just
wasn't
ready.
Today,
it's
gonna
be
another
week
or
so,
and
so
we'll
be
looking
at
air
throughout
this
presentation
and
what
acmarine,
what
that
ecosystem
allows
you
to
do.
A
Is
it
really
enables
you
to
separate
the
orchestration
from
the
service
business
logic
and
that's
a
huge,
huge
step
towards
getting
these
efficiencies
possible
for
peer-to-peer
networks?
It
obviously
allows
you
to
do
peer-to-peer
applications
and
another
aspect.
That's
inherent
it's
a
first-class
citizen
in
within
the
fluence
aquamarine
vision
is
that
it
allows
you
to
build
zero
trust
applications
right
out
of
the
box.
For
those
of
you
just
I'm
just
gonna
go
very
quickly.
A
Zero
trust,
applications
or
sierra
trust
is
basically
trust.
Nobody!
It's
it's
an
approach.
It's
a
security
approach
to
networks,
that's
really
gathering
and
and
getting
momentum,
and
you
trust
nobody,
nothing.
Everything
needs
to
be
authenticated.
Everything
needs
to
be
authorized.
There
is
no
inherent
trust
in
anything
and
that's
a
really
really
increasingly
popular
and
necessary
framework,
as
we
start
breaking
down
walls
of
our
infrastructures
and
get
more
and
more
interconnected
and
collaborative,
and
this
is
inherent
in
the
aquamarine
design
and
we'll
get
to
that
with
an
example
and
so
at
the
bottom.
A
It
basically
just
shows
you
how
it
all
fits
together
now
in
order
to
get
all
this
done,
you
need
a
solid
foundation.
If
you
develop
an
a
system
like
ak,
marine,
you
got
to
have
a
solid
foundation
and
our
solid
foundation
is
inspired
by
pi
calculus
pi
calculus
is,
if
you
want
to
take
anything
away
from
this.
It
basically
gives
you
the
mathematical
tools
to
describe
and
model
concurrent
systems
with
dynamic
type
of
topologies,
and
this
is
crucial.
A
Everything
else
is
wonderful
and
it
allows
us
to
model
and
verify
and
and
then
actually
build
a
system
and
instructions
operators,
but
it's
the
that
being
able
to
model
dynamic,
topologies
is
is
huge
and
the
reason
for
that
is
the
following:
in
peer-to-peer
networks
are
many
distributed,
networks
peers
come
and
go,
it's
expected
behavior,
not
exception
behavior,
and
that
makes
it
very
very
tricky
and
difficult
to
model
because,
as
I
said,
like
a
route
you
were
able
to
execute
one
second
ago
may
just
not
be
available
to
you
anymore.
So
this
is
so.
A
So
how
do
you
actually?
Let
me
just
go
back
so
pi
calculus
comes
with
a
few
operators
and
if
you
ever
been
exposed
to
say
a
lambda
calculus,
for
example,
you
know
that
a
handful
of
operators
in
those
formal
languages
and
algebras
are
extremely
powerful
and
basically
let
you
do
just
about
anything
you
need
to
do
so.
How
do
you
go
from
the
theory
then,
to
the
implementation?
Well,
we
have
a
few
instructions
as
well
derived
from
the
pi
calculus
and
we
basically
have
an
execution
command.
A
We
have
a
sequential
parallel
processing,
we
have
a
fold
operation
and
branching
and
an
identity.
So
that's
not
much,
but
it
actually
it's
extremely
powerful
and
lets
you
get
a
lot
of
work
done
very
very
quickly.
So
what
does
it
look
like
in
air
air
recall?
Is
the
it's
a
low
level
language
we're
looking
at,
so
you
look
at
an
instruction
set.
A
That's
basically
comprised
of
an
instruction
like
called
the
execution
and
then
data
pertinent
to
the
service
and
the
node.
So
basically,
what
this
statement
here
says
it.
Basically,
it
says,
call
the
function
put
for
service
dht
at
node
peer
id,
give
it
the
value,
give
it
the
two
values
key
and
value,
and
I
expect
a
named
output
called
result.
A
And
that's
it
and
we'll
we'll
go
through
all
this
a
little
bit
more
in
detail,
obviously,
and
but
that's
that's
extremely
powerful
notion,
so
your
location,
your
peer
id,
obviously
needs.
This
is
dynamic.
Your
service
id
may
be
dynamic
and
your
function
is
actually
fixed
in
the
sense
that
it
corresponds
to
the
public
api
of
the
service
reference
and
the
key
values
actually
are
being
piped
into
the
instruction
set.
So
then
you
get
your
result,
that's
it
and
that
actually
allows
you
to
do
a
lot
in
terms
of
peer-to-peer
programming.
A
However,
we
need
one
more
construct
in
order
for,
in
order
to
go
from
one
peer
service
to
another
peer
service.
Without
ever
going
back
to
your
client,
you
need
you
need
you
need
something
that
knows
what's
going
on,
and
this
is
what
we
call
a
particle.
So
particle
is
a
data
structure
that
combines
data,
the
execution
sequence
and
some
metadata
and
how
this
is
implemented.
We
see
on
the
right.
A
The
white
squares
are
the
nodes
and
the
really
red
dots
are
the
services
on
a
node
and
you
can
have
more
than
one
service,
obviously
per
node
and
then,
depending
on
your
service
requirements,
you
build.
You
write
your
air
script
like,
for
example,
on
the
right
again,
which
is
the
same
as
from
the
previous
slide,
and
now
this
particle
starts
traversing
the
network.
A
According
to
the
programmatic
specification
you,
the
developer
has
given
it
to
do,
and
in
this
case
so
we're
going
from
the
browser
to
to
some
services,
and
then
we
end
up
at
at
the
chrome.
So,
for
example,
I'm
sending
a
message,
so
we
got
a
message
service
somewhere
and
we
want
to
add
emoji.
So
we
got
an
emoji
service
somewhere
with
a
file
upload
right
there,
and
then
it
goes
to
the
chrome
browser.
A
Let
me
go,
let
me
stay
on
the
slide
for
a
second.
As
I
said
in
in
the
response
request
by
separating
the
workflow,
you
take
a
huge
load
of
your
front-end
application
in
terms
of
resources
required
to
host
it
and
to
run
it
and
that
actually
changes
or
could
change
where
an
application
is
is
hosted.
So
lighter
requirements
allow
us
to
host
applications,
particularly
with
webassembly,
in
browsers
on
on
very
light
mobile
devices
and
on
iot
devices,
and
particularly
on
the
industrial
side.
A
Peer-To-Peer,
networking
and
iot,
I
think,
has
a
huge,
huge
future.
It's
already
taking
place
and
with
peer-to-peer,
obviously
you're
somewhat
transport
agnostic,
especially
with
lib
p2p,
and
you
can
very
easily
switch
to
wi-fi
direct
or
a
variety
of
mesh
networks
which
are
extremely
pertinent
to
iot.
A
So
as
so
again,
this
is
an
extremely
powerful
way
to
lighten
the
requirements
for
your
client
and
take
advantage
of
the
capabilities
at
the
node
level,
which
we
believe
is
a
huge
huge,
huge
advantage
over
traditional
programming
approaches
and
network
approaches.
So
where
does
this
get
us
so
for
the
purpose
of
this
presentation?
So
I
I
ended
up
coding
up
a
couple
services
and,
let's
just
go
through
them.
One
is
called
an
echo
service
and,
let's
just
say,
it's
deployed
on
pa
and.
A
But
fundamentally,
what
we're
doing
here
is
we're
taking
an
input
which
is
an
array
of
strings
and
returning
an
array
of
echo
structs,
which
the
only
member
is
a
string
and
obviously
that
doesn't
really
mean
much,
but
I
needed
an
entry
into
a
service
and
the
entry
rather
than
building
an
sql
or
mysqlite
or
whatever
service.
This
is
just
very
quick
and
it's
a
proxy
to
stand
in
for
any
kind
of
database
or
other
storage
based
service.
You
could
possibly
imagine,
and
then
we
have
a
greeting
service.
A
The
green
service
basically
just
takes
a
name
which
is
a
string,
and
now-
and
let's
just
say,
the
greeting
services
are
deployed
on
on
different
peers,
multiple
peers.
So
how
do
we
actually
go
from
the
echo
service
to
the
greeting
service
and
we
do
this
with
aquamarine?
So
the
services
are
the
same,
so
I
just
really
made
them
very
small,
and
so
now
we
build
an
aquamarines
and
an
airscript
and
basically
so
don't
don't
be
afraid
of
the
parentheses
it's
once
agua
comes
along.
A
Our
values
are
names
which
are
piped
in
and
in
our
case,
if
you
look
to
the
right
are
bob
bill
and
jack.
So
what
can
we
do
now?
So
we
now
specify
a
workflow
that
calls
that
calls
the
greeting
services
by
decomposing.
The
result
the
named
output,
echo
result
is
now
the
input
directly
into
subsequent
services
in
order
to
get
a
semi-decent
size
of
the
diagram
of
the
code
on
the
screen.
I
only
use
two
grading
services
and
what
we're
doing
is
we're
basically
we're
decomposing.
A
The
echo
result
manually
in
this
case
into
into
two
arguments
for
two
different
services,
one
on
node,
two
one
on
node,
three
one
is
grading
service.
One
one
is
screening
service
two
and
then
at
the
end,
in
in
each
call,
we
now
have
a
named
output
and
there
are
two
separate
ones:
a
greater
result
from
the
first
service
and
the
greater
result
from
the
second
service
and
then
at
the
end.
A
We
now
call
and
check
on
our
results,
and
this
is
what
we
get.
We
only
use
two
service
and
we
had
bob
bill
and
jack
going
in
and
we
have
bob
and
bill
coming
out
because
we
only
use
two
and
if
you
look
at
the
decomposition
echo
result,
zero
acre
result,
one
is
bob
and
bill
and
that's
what
we
got
back.
A
So
this
is
how
we
took
advantage
in
a
kind
of
a
lame
way,
with
sequential
processing
and
knowing
the
inputs
to
quickly
get
to
the
workflow
into
the
consuming
service
and
values.
However,
we
can
do
better
and
how
we
do
better
is
we
use
fold,
we
use
an
iterator
and
what
we've
done
here
now
is.
We
have
we
call
again
the
same
service,
the
echo
service
and
we
pipe
in
bob
bill
and
jack.
A
Right
here
and
we
basically
decompo
and
called
our
our
iterator
valley,
variable
item
and
then
we
just
go
to
onenote
greetingservice1
and
we
pipe
in
the
item
iteratively
and
we
get
a
array
of
results
now
which,
as
you
see,
is
high
bar
built
in
jack.
So
that's
pretty
cool
didn't
have
to
do
anything
and
again
the
particle
traveled
from
the
echo
service
to
the
greeting
service
and
iterated
over
the
requirements.
A
Well,
it's
deployed
from
a
from
an
application,
so
so
I'll
show
it
to
you
in
a
minute,
but
once
it
it's
it's
released
in
the
wild.
If
you
will
it
travels
according
to
the
path
you
give
it,
you
programmatically
specify
it
so
the
logic
to
route
the
the
resolution
logic
is
on
each
of
the
nodes,
so
a
vm
and
aquamarine
vm
is
on
every
node.
Is
that
your
question
for
them.
A
A
So
and
if
you
look
at
the
length
of
the
the
program,
if
the
air,
it's
it's,
it's
super
super
efficient
and
you
can.
Actually,
you
can
accomplish
a
lot
with
relatively
little
code
in
in
in
this
peer-to-peer
environment
in
part,
because
the
aquamarine
components,
especially
the
vm,
take
care
of
of
all
the
heavy
lifting,
and
that
is
really
the
whole
point
to
to
make
it
easier
to
to
make
it
accessible
and
for
you
to
as
a
developer,
to
have
fun
doing
it
and
actually
get
results
you
want.
A
So
I'm
missing
a
slide.
Now.
Big
surprise
hang
on
okay,
so
I
wanted
to
show
you
one
more
thing.
I
talked
about
zero
trust
and
inherent
security
and
in
act.
Marine
services
are
exposed,
actions,
informal
functions
and
they
may
require
authorization,
and
the
easiest
concept
is
what's
generally
referred
to
ambient
authorization.
Where
authentication
gives
you
authorization,
it's
basically
it's
in
linux
or
most
operating
system,
that's
how
it
gets
right.
A
You
get
a
user
user
of
authentication,
and
that
gives
you
an
ambient
authorization
realm
to
work
within,
and
that's
pretty
much
where
you
get
out
of
the
out
of
out
of
the
box
without
marine,
even
though
you
can,
you
can
extend
this
very
very
significantly,
and
the
the
core
concept
in
aquamarine
is
that
of
a
tetraploid,
which
is
basically
the
peer
id,
the
service
id
the
function
name
and
the
data
getter,
and
that
allows
you
to
enable
secure
composition
of
functions
within
air.
So
now
let
me
switch
okay.
A
A
A
A
Another
service
is
probably
too
small,
so
let
me
here
so
the
greeting
service
we
saw
before
I
re-implemented
that,
but
now
I'm
putting
in
a
check
whether
or
not
the
collar
is
actually
the
owner
of
the
service,
so
anybody
has
ever
done
any
solidity
programming.
For
example,
you
know
this
like
origin,
encodes
owner
and
the
way
we've
done.
That
is.
We
inherently
take
advantage
of
the
security
tetraplethic
that's
built
in
that
comes
with
aquamarine
and
we
do
the
is
owner
check
and
from
the
inherent
call
parameters.
A
That's
where
we
really
start
referring
to
the
security
tetraplet.
We
we
check
whether
or
not
the
caller
is
the
initiating
peer
id
and
whether
the
owner
is
the
server's
creator
peer
id,
and
then
we
just
do
the
boolean
check,
and
that
gives
us
whether
or
not
somebody
is
the
owner
of
the
service.
As
I
said,
this
is
ambient
authorization.
There
is
much
more
we
can
do,
but
I
think
for
today
this
is
pretty
much
all
we
need
to
do
so
now
going
back
to
the
greeter.
A
So
if
if,
if
you're,
not
the
owner,
you
get
an
error
and
if
you
are
the
owner,
you
get
your
high
whatever
and
instead
of
just
a
string,
I
created
a
small
struct.
I
call
it
greeting
result
or
result,
and
it
has
two
members
public,
obviously,
once
the
greeting
and
the
error
string,
so
you
have
to
put
a
little
bit
of
effort
in
resolving
whether
or
not
this
is
a
good
call
or
a
back
call,
but
it's
not
particularly
difficult.
A
A
So
all
right-
this
is
probably
also
way
too
small,
I'm
using
a
tool
called
fl
dist,
which
is
a
tool,
a
fluence
tool,
command
line
tool
to
interact
with
the
node
and
to
build
to
deploy
services
to
do
all
the
kind
of
heavy
lifting.
You
can
also
use
a
javascript
sdk
to
to
build
actual
applications
rather
than
just
command
line,
but
for
our
purposes
the
command
line
should
just
do
so.
What
are
we
doing?
This
is
the
this.
Is
the
cli
application
now
we're
giving
it
now
we're
feeding
it?
A
We
want
to
run
an
air
script
and
the
air
script
is
called
great
cl,
jake
foreclosure-
and
let
me
just
I
forgot
to
show
you
that
your
scripts,
this
is
the
script,
we're
calling.
So
basically
what
we're
doing
so,
the
xor
the
branching
is
basically
it's
an
error.
Catch
right.
I
think
you've
seen
that
if,
if
the
first
branch
doesn't
execute
properly,
you
get
the
second
branch,
and
that
gives
you
the
actual
error
message
or
the
last
error
through
the
execution
execution
loop
and
so
what
we're
doing?
A
Basically,
you
don't
see
any
difference
than
what
you've
seen
before
we,
we
call
the
greeter
with
the
greeting
the
greeting
service,
with
the
greeting
function.
We
give
it
the
name
on
the
node
which
we
fill
in
and
then
we
get
back
our
result,
and
that
was
the
part
I
have
shown
in
the
presentation
for
the
in
the
slides.
For
the
other
examples,
so
we
had
the
node,
we
give
it
the
node
address.
A
We
give
it
the
command,
which
is
run
the
air
script.
We
give
it
the
location
of
the
airscript,
and
I
just
showed
you
what
it
looks
like
and
now
we
come.
The
data
here
comes
the
data,
we're
piping
in
the
data
and
in
the
air
script.
You
saw
the
reference
to
the
node,
which
was
the
node
id,
and
we
pipe
it
in
like
this,
and
then
we
need
the
greeter,
which
is
this
greeting
service.
A
If
you
recall,
which
is
this-
and
this
I
got
from
when
I
created
the
service,
so
when
you
create
a
service,
you
actually
have
to
take
some
notes
manually
or
otherwise,
and
you
have
to
take
a
hold
of
your
greeting
service.
Although
the
service
id
you
can
retrieve
a
differently
from
our
dashboard,
for
example,
and
I'll
show
you
the
dashboard
in
a
minute
and
then
the
name
we
pipe
in
was
just
booyah,
and
now
we
run
it.
A
Oh
look
at
that.
I
am
not
the
owner,
I
got
barred
and
there
is
no
greeting
for
us,
and
the
reason
for
that
is
that
we
didn't
provide
the
authorization
credentials
necessary,
and
here
is
so
here
now
we
got
the
additional
flag,
which
is
called
the
client
seed
or
the
seed,
and
you
get
the
express
you
get
the
token
and
that
I
also
got
when
I
created
the
service
or
I
could
have
specified
it
as
I
was
creating
the
service,
and
this
is
obviously
super
secret.
A
You
should
not
share
this
with
anybody,
particularly
if
you're
using
it
to
guard
your
service
with
the
authorization
and
now,
let's
see,
if
we
add
that
to
our
our
our
data,
what
happens
all
right
all
right?
I
didn't
screw
up.
Okay,
I
did
it
late
and
now
we
are
authorized
and
we
get
the
expected
greeting
any
questions
about
this
right.
A
Marine
through,
what's
called
a
secure,
what
we
call
a
security
tetraplate,
so
it's
in
the
out
of
box-
and
all
you
have
to
do-
is
write
this
one
little
function
in
my
owner
or
whatever
you
want
to
call
it
and
and
just
start
guarding
your
functions
as
on
a
per
function
level
as
necessary,
and
that's
really
really
powerful
so
and
it
gets
and
also
necessary.
So
imagine
you
have
you
know
you
running
a
database,
for
example.
A
You
obviously
want
this
to
be
guarded,
because
otherwise
everybody
is
going
to
start
overriding
your
data
and
because
one
thing
I
don't
know,
if
I
mentioned
this,
I
mean
one
of
the
the
whole.
The
big
ideas
really
is
that
all
this
is
happening
in
permissionless
peer-to-peer
networks
right
this
is
this
isn't
private.
This
is
this.
Is
these
are
permissionless
peer-to-peer
networks
where
peers
can
join?
They
can
choose
what
kind
of
services
they
want
to
host.
So
it's
it's.
A
It's
it's
a
really,
really
powerful,
yet
simple
way
of
bringing
security
into
access
security
into
a
permissionless,
peer-to-peer
or
otherwise
distributed
network,
and,
as
you
can
tell
I'm
obviously
extremely
inarmored
with
the
notion
and
the
capability,
because
I
think
it's
it's.
It's
super
super
cool
and
it
solves
a
huge,
huge
problem
in
that
space
at
no
expense
of
the
developer.
A
So
since
I
mean
obviously
you
can't
protect
exposed
methods
to
go
in
private
right,
so
you
have
to
use
this
authentication
mechanism
and
that
allows
you
to
choreograph
services
into
applications
independently
from
the
services.
Business
logic
concerns,
and
I
sort
of
showed
you
that,
with
that
one
example,
the
contrived
example
where
we
paralyzed
parallel
inputted
the
arrays
into
two
different
services
and
or
different
use
cases
of
one
service,
and
this
was
all
without
ever
touching
the
service.
A
And
that's
that's
one
of
the
huge
powers
of
peer-to-peer
and
act.
Marine
really
allows
you
to
to
access
that
power
very
very
easily.
In
my
opinion,
there's
a
little
bit
of
learning
curve.
Obviously,
but
it's
I
don't
think
it's
particularly
hard.
So
from
my
end,
that's
pretty
much
it,
but
obviously
I'm
more
than
happy
to
discuss
and.
A
A
A
A
A
A
So
in
the
sequential
one,
which
was,
I
think,
the
first,
the
second
example
this
is
the
air
script
and
I've
been
calling
to
return
service
up
here.
So
we
called
the
echo
service
we
piped
in
the
data,
and
then
I
I
called
for
the
results
which
was
necessary,
and
this
is
how
you
can
start
tracing
where
things
happen
and
where
things
go
wrong
now.
In
addition,
in
addition,
if
I
we
can
have
this
built
in.
A
A
A
A
A
A
And,
and
so
that
does
two
things
first
of
all
it
it
doesn't
just
crash,
you
don't
get
a
panic
right.
You
basically
get
a
clean,
clean
exit
from
your
program
and,
second
of
all,
it
literally
gives
you.
I
mean
it's
the
last
area.
It
gives
you
the
last
error
that
causes
which
what
I
quote
from
your
perspective
is
the
first
error
right,
because
it's
it
is
where
it
failed,
and
that
gives
you
a
certain
degree
of
fault
tolerance
in
the
sense
that
you
don't
end
up
with
a
panic
and
b.
A
A
However,
knowing
at
least
some
of
it
and
why
we're
doing
what
we're
doing
is,
in
my
opinion,
at
this
stage,
just
as
important
as
as
it
is
to
to
know
how
to
use
it
and,
as
I
said
on
the
outside,
most
of
our
our
code
is
raw
space
and
I
think
and
alexi
can
chime
in
any
time.
We
are
super
super
happy
with
with
rust.
It
brings
a
lot
of
capabilities.
It
brings
ergonomics,
which
I
think
you
even
see
in
in
air
a
way
of
thinking
and.
A
You'll
see
it's
it's
a
super
tight
implementation
of
the
interpreter
and
the
capabilities
russ
brings
with
to
to
compile
into
laws
and
targets
is
just
awesome
and
anyway
so
we're,
I
think,
we're
super
happy
with
it,
and
I
think
it
would
have
been
much
harder
to
build
the
aquamarine
system
in
say,
c,
c,
plus,
plus
or
anything
else.
I
don't
know
if
anything
else
would
have
been
possible,
then
rust
so
and
as
when.
A
I
think
over
time
we're
gonna
go
we're
gonna,
open
up
our
web
assembly
languages,
but
right
now
it's
all
rus.
If
you
want
to
build
services,
oh
yeah,
so
one
thing,
that's
really
important
is
sort
of.
There
is
an
inherent
division
of
labor
in
these
peer-to-peer
application
and
networks,
and
the
division
of
labor
may
not
be
clear,
but
it's
certainly
there,
and
one
of
the
really
empowering
aspects
is
that
you
have
nodes
that
can
be
operated
by
hosters
or
node
operators.
You
have
services
like
the
greeting
service
and
the
echo
service.
A
A
A
To
me,
this
is
an
extremely
extremely
powerful
mine.
It's
extra
slow
loading
today,
of
course,
it
is
extra,
slow,
extra,
powerful,
sorry,
extra,
powerful
approach
to
to
developing
our
applications,
and
I
want
to
go
back
to
the
presentation
one
time
since
I
you
are
a
little
bit
on
the
quiet
side.
I
actually,
I
actually
developed
a
little
facts
section
myself.
A
So
how
do
I
access
services,
such
as
generic
web
to
endpoints
not
hosted
on
the
peer-to-peer
network?
So
this
is
a
really
good
question
to
myself.
Basically,
what
you
need
to
do
you
gotta
you
gotta,
build
proxy
services,
also
known
as
adapters
that
are
hosted
on
the
peer-to-peer
network
and
we
have
a
whole
bunch.
A
A
I
you
can
do
this,
obviously,
but
ak
marine
is
really
really
empowering
you
to
participate
and
safely
participate
in
permissionless
peer-to-peer
networks
where
you
get
the
power
and
the
fault,
tolerance
of
other
peers
out
there
contributing,
and
so
no
you
don't
have
to
run
one.
But
you
may
want
to
run
your
own
node,
but
you
don't
have
to
run
a
network
at
all
as
it
stands
right
now,
we're
even
providing
a
test
net
for
the
development
purposes,
and
so
you
don't
even
have
to
run
a
node.
A
Now
that
was
another
great
question
and
oh
yeah
and
I
said
somewhere
along
the
talk
I
said
monetization.
We
want
to
empower
developers
to
monetize
their
their
work
and
one
of
the
things
we're
doing
we're
in
the
process
of
developing
a
blockchain
based
licensing
system
for
open
source
software,
peer-to-peer
software
and
trying
to
shift
the
value
capture
from
the
big
cloud
operators
who
currently
basically
capture
all
the
value
pretty
much,
particularly
on
open
source
contributions
to
open
source
developers.
A
Development
actually
start,
can
monetize
much
better
than
in
any
other
environment.
If
that
is
something
you
are
interested
in
so
now,
okay,
so
all
right!
So
this,
okay,
yes,
and
no
so
so.
The
question
is,
is
I
hope,
my
pronunciation
name
correctly?
How
do
we
maintain
latency
slas
slas
is
interesting
and
I
think,
within
a
peer-to-peer
environment.
Fundamentally,
you
have
to
rethink
your
slas
a
little
bit.
A
A
A
So
if
you
shubaam
want
to
give
five
nines
on
your
service,
then
you
are
totally
happy
or
eligible
to
do
so.
If
I
was
you-
and
I
was
doing
this,
I
would
very
very
much
probably
run
my
own
nodes
right.
I
mean
you
should
be
able
to
monetize.
If
you're
giving
five
nines,
you
should
be
able
to
monetize
and
if
you're,
if
you
monetize,
if
you're
able
to
monetize,
then
you
probably
want
to
run
your
own
notes
in
order
to
eliminate
any
failure
or
at
least
control
your
your
failure,
possibilities
and
probabilities.
A
So,
okay,
I
wouldn't
necessarily
call
it
a
private
network,
one
of
the
things
that
alexei
actually
asked
me
to
to
put
it
in
the
presentation-
and
I
didn't
want
to
because
I
thought
it
might
confuse
things
a
little
bit,
one
of
the
things
you're
doing
when
you're
building
your
airstrip
you're,
basically
building
a
sort
of
a
temporal
virtual
private
network
right
because
the
realm,
your
your
topology
of
the
execution
path,
is
really
limited
to
what
you're
specifying
programmatically
within
the
airscript.
So
you
don't
need
to
run
a
private
network.
A
You
can
run
you
can
host
other
people's
services
as
well.
Right
I
mean
it's,
not
it's
not
an
isomorphic
relationship,
another
one
to
one
relationship
between
a
service
and
a
network,
a
network
node
a
node
can
run
as
many
services
as
it
has
capacity
for
so
you
can
still
operate
in
a
permissionless
public
network,
but
provide
performance
guarantees
around
your
specific
nodes.
A
It's
almost
like
the
inverse
of
of
staking
nodes
right
and
well,
it's
not
the
inverse,
but
it's
like
staking
notes.
I
mean
you
run
your
own
sticking
nodes
in
in
the
blockchain
environment
and
you're
still
part
of
the
the
the
public
system,
but
it's
your
nodes.
You
guarantee
their
availability
and,
unlike
an
asset
and
the
sla
equivalent,
is
basically,
if
your
staking
notes,
don't
perform
or
run
when
it's
supposed
to
run,
you
get
slashed
and
basically
in
you
can
look
at
it
the
same
way.
A
A
Okay,
cool
so
yeah,
I
am
obviously,
as
you
can
see
like
I'm
I'm
very
like
I'm,
not
a
big
fan
of
of
private,
in
the
sense
that
you
have
to
run
your
network,
because
this.
This
is
almost
like,
defeating
the
purpose
of
having
peer-to-peer
right,
because,
if
you're
on
your
private
you're
centralized
if
you're
centralized,
you
probably
could
just
run
it
on
a
cloud
on
a
basic
cloud
setup.
A
A
All
right,
I
that's
all
I
got
folks
very.
Thank
you
very,
very
much
for
for
having
me
and
thank
you
for
being
here.
I
apologize
for
the
the
snafu
with
the
slides
I'll
I'll
make
him
available
as
a
pdf
I'll,
send
them
to
them
out,
and
you
all
have
a
great
great
evening
great
weekend,
stay
safe
and
thank
you
very
much.