►
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
A
It's
needed
for
like
to
revise
the
role
of
aqua
vm
in
our
architecture.
At
all,
then
we
will
talk
a
lot
about
aquarium
execution
model,
how
it
performs,
how
it
performs
operation
our
data,
how
it
produces
list
of
peers
to
send
data,
then
after
execution
and
etc,
etc.
Finally,
we
will
go
about
air
instructions.
There
will
be
some
intersection
with
the
dimitri's
talk,
especially
about
construction,
and
finally,
I
will
talk
about
some
main
principles.
Some
topics
on
aquarium
probably
is
the
most
important
ones
but
like
during
this
45
minutes.
A
I
definitely
won't
have
like
won't
cover
all
topics
on
ico
vm
because
because
we
have
been
developing
it
for
about
two
years
yeah
two
years
and
like
there
are
some
very
low
level
and
very
complex
topic
regarding
crdt,
so
I
won't
cover
it
and
but
if
you
want
to
like
find
more
information,
please
ask
me
or
us
so
we
will
try
to
answer
your
questions.
A
Of
all,
let's
see
on
the
what
I
call
only
I
only
me
I
call
fluence
one
which
stack
so
actually
we
have
aqua,
yes,
that
dimitri
and
alexey
show
already
we
have
aqua
compiler
written
on
scala
and
this
compiler
compiles
aqua
to
air
and
javascript
or
arm
typescript.
It
doesn't
matter,
and
then
this
compiled
code
in
so
error
stands
for
akumar
intermediate
presentation
and
this
compiled
code
execution,
our
aqua
vm
in
itself,
written
on
rust
and
compiles
the
web
assembly
and
run
inside
our
own
runtime
called
marine.
So
it's
general
purpose
of
assembly
runtime.
A
B
A
Could
see
like
some
needed
part
for
my
talk
of
the
fluency
architecture,
not
all
but
needed
so
probably
the
best
way
to
approach
this
picture
is
starting
from
bottom
to
top
so
on
and
like
internal
influence,
we
consider
fluency
architecture
as
a
way
red
one.
So,
on
the
first
layer
we
usually
put
lip2p
as
a
like
the
factor
standard
for
connectivity
in
p2p
networks
and
from
lipid2p
we're
using
a
bunch
of
algorithms
like
ademya,
identify,
heartbeat
and
so
on,
and
then
on
the
second
layer.
There
is
a
fluence
pier
itself
like
fluence
node.
A
A
A
Sir
fluent
service,
but
and
basically
service
is
just
a
web
assembly
application
and,
as
alexa
said
like,
we
hope
on
future
service
could
be
like
javascript
and
etc.
So
it
doesn't
matter,
it
could
be
even
like
docker
container,
it's
like
for
the
stock,
it
doesn't
measure,
so
there
is
something
that
could
be
called
and
it's
located
on
a
like
a
concrete,
pier
in
a
network,
and
there
is
a
queue
that
manages
this
services
inside
our
runtime
and
the
last
one
on
the
website.
A
There's
a
queue
of
that
manages,
pool
of
aqua,
vm
and
aqua
vms
is
like,
as
already
said,
the
compiled
webassembly
run
in
our
run
time,
and
on
this
right
you
could
see
like
a
picture
if
we
step
like
up
snc
like
on
our
network
at
all,
and
here
you
can
see
that
we
have
fluent
spears
and
actually
this
client
they
also
fluent
spears,
meaning
that
they
also
could
serve
services
and
on
each
peer
in
network.
A
There
is
a
aqua
vm,
it's
necessary,
so
an
aqua,
vm,
compost,
web
assembly
run
both
server
side
and
both
coin
side
is
always
like
web
assembly
main
pro
and
like
aqua,
vm
orchestrates
how
packet
network
packet
like
pass
through
our
network
and
in
this
term,
it's
necessary
that
it
like
located
on
every
peering
network
and
before
we
start
before
we
dive
into
deep
the
details
of
aquarium.
A
I
want
to
be
a
bit
for
sofco
one
so
like
aquarium
is
a
complex
beast
and
we
have
our
own
way
to
like
approach
the
complexity,
and
this
way
is
based
on
a
homomorphic
mapping.
So,
like
it's
it's
mass
term,
but
like
all
of
you
know
it
all
of
you,
use
it
like
every
day.
It's
just
the
idea
of
similar
similarity
between
different
objects,
so,
like
here
or
this,
like
this
simple
formula,
says
that
oh,
we
have
operation
our
one
algebraic
structure
or
one
something
and
like
it
should
preserve
to
be
homomorphic.
A
To
preserve
this,
like
internal
structure
structure
in
one
area,
this
one
x
code,
usually
codamine
and
y,
usually
called
domain,
so
it
should
preserve
structure
on
codomain
in
the
main,
it's
necessary
to
be
homomorphic,
and
why
why
I
say
about
that
because,
usually
like
when
you
invent
something
when
you
research,
something
you
can't
like
usually
can't
get
ideas
from
the
thin
air?
Yes,
you
can't
just
I
know,
invent
them,
you're
basing
on
something
on
some
some
basics.
A
Yes,
but
usually
you
could
invent
something
like
out
of
scenario
but
wouldn't
be
useful,
I'm
not
sure,
and
why?
What
is
the
domain?
In
our
case?
So
as
like
alexey
dmitry
says,
we
heavily
used
pi
calculus
and
almost
all
our
instructions
are
derived
from
pi
calculus.
I
will
show
you
later
the
notes
we
use
on
the
calculus,
abstract,
algebra,
category
theory,
graph
theory,
fine
state
machine
and
compiler
theory,
and
the
last
one
you
could
see
toa
pass
that
we
dreaming
to
use.
A
We
dreaming
to
describe
our
part
of
our
system
on
aquarium
and
toy
plus
and
actually
like
here,
also
like
philosophical
topic,
because
you
know
like
remember
the
and
technique
like
feminine
technique
says
that
to
understand
something
you
need
to
be
able
to
describe
it
in
very
simple
words
like
that
would
be
understandable
by
fifth
years
old
person
or
10
years
old
doesn't
matter,
and
here
is
also
homomorphic
mapping,
because
you
map
from
some
rich
area
to
some,
not
so
rich
areas
like
area
of
simple
words
that
understandable
by
by
children.
A
Yes-
but
you
know
like
this,
if
you
could
combine
in
a
simple
words,
you
know
the
mapping
between
these
four
linking
businesses
for
people
understand
everything
in
this
topic
and
this
how
ca
plus
also
works?
It's
not
it's
not
just
a
verifier
system,
not
just
your
system,
but
if
you
could
express
your
system
on
cyprus,
so
usually
you
could
obtain
some
something
new
about
your
systems
that
you
probably
couldn't
wear
before.
A
A
Okay,
let's
like
step
back
from
the
philosophical
question
and
come
to
the
execution
model,
and
the
first
thing
in
this
execution
model
is
like
conception
of
particle,
so
particle
actually
is
a
data
structure
that
contains
several
fields
that
describes
your
request.
So
there
are
several
important
fields
here
like
script.
Script
is
actually
it's
error.
Script,
and
now
we
don't
have
a
binary
format.
So
it's
just
a
string,
so
it
doesn't.
It
doesn't
necessarily
actually
because,
like
it
works,
it
works
pretty
fast.
A
We
could
show
you
them,
so
it's
it
doesn't
like
influence
performance
much
and
the
the
most
important
thing
here
most
important
field
is
the
last
one
is
data.
So
all
previous
fields,
like
timestamp,
ttl,
signature,
script,
initial
pure
id
and
id
they
are
immutable,
meaning
that,
like
in
all
networks,
sorry
no
network
packets
that
belong
to
this
particle,
this
this
fields
will
be
the
same,
but
data
could
be
changed.
A
A
A
Okay,
so
then,
let's
consider
aqua
vm
is
a
fine
state
machine.
As
I
already
said,
we
have
like
we
used
homomorphic
mapping
and
on
the
slides,
you
could
see
these
like
blue
rectangles
on
the
this
corner,
and
so
on.
This
like
represent.
What
is
the
theory
behind
this,
and
here
is
a
very
simple
concept?
Yes,
and
so
aquavium
is
a
pure
state
transition
function.
So
it's
like
clean
state
machine.
There
are
it's
just
like
code
on
rust
compiles
web
assembly
without
any
inverse.
A
A
The
first
one
is
the
current
state
that
just
come
from
a
network
from
a
particle
and
previous
state.
What
I
call
previous
state
is
a
last
produced
by
this
aquavium,
like
belongs
to
current
particle
id
and
saved
on
this
node.
So
node
is
a
responsible
for
saving
a
state
that
produces
by
this
aquavium
on
appear,
belong
to
current
particle
and
then
give
it
back
to
aquarium
when
a
new
particle
comes
and
aquarium
produces
new
state
or
new
data,
so
actually
hero
state
equals
to
data.
A
So
when,
when
you
see
this
data
is
actually
like
state
on
this
picture
and
also
it
produces
a
list
of
peers
and
node
is
responsible
for
sending
this
new
state
to
the
peers
that
are
allocated
in
this
list,
how
it
looks
like
so
in
the
queue
there
is
a
like
new
event,
saying
no
soul.
Note
please
take
this
data
and
send
it
to
this
network
peers.
A
So
it's
rather
simple
and
notice,
not
as
responsible
to
do
all
this
magic
behind
the
cues
and
just
to
produce
network
events.
And
so
then
it's
really
b2b,
but
it's
not
all.
A
There
are
more
arrows
here
on
this
picture
so
like
additionally
to
current
and
previous
states,
there
is
a
core
results
and
call
requests.
A
I
will
just
say
couple
four
here
and
later
we
will
see
why
they
are
needed,
like
in
more
details.
So
akubem
is
a
pure
function,
so
but
aqua
vm
need
to
be
called.
So
you
already
said
instruction
call
that
code
like
services
located
on
appear.
It's
somewhere
need
to
be
done.
That's
like
there
should
be
a
way
to
do
that,
but
iqm
is
a
pure
function
so
and
acquaint
produces
a
co
request.
A
A
That's
why
it
that
how
it
works
from
a.
Why
is
that
called
interface
of
aquarium
looks
like
and
like
seeing
to
this
arrows.
There
are
two
reasons
to
run
acrovm
on
the
host.
The
first
one
is
a
handle
current
data
or
current
state
that
comes
just
come
from
a
network
from
particle,
and
second
reason
is
to
handle
core
results
that
just
produced
by
a
code
service.
A
There
are
some
advantages
and
disadvantages
of
the
scheme,
but
in
our
opinion,
like
these
advent
disadvantages,
they're,
not
so
sufficient,
they're,
just
like
mostly
about
time
consuming
in
performance,
but
it's
word
out.
A
Probably,
if
you
ask
questions,
then
I
will
cover
this
topic
in
more
details,
but
there
are
a
lot
of
advantages.
The
first
one
is
like
interpreters
pure
function.
Second,
one
this
scheme
allows
you
to
call
service
in
parallel
and
synchronously.
For
example,
the
scheme
allows
you
to
do
a
timeout
pattern.
Remember,
like
example,
of
alexi.
When
we
have
timeout
on
join,
like
without
the
scheme,
it
wouldn't
be,
it
wouldn't
be
possible,
and
also
it's
like
also
brings
you
to
use
timeout
is
that
the
execution
takes
a
fixed
time.
A
And
here
you
could
see
like
the
basics,
very
basics
of
pi
calculus,
so
actually
pi
calculus
is
like
maybe
the
most
adapted
for
describing
distributed
systems,
peer-to-peer
systems
carcass
like
that
was
intended,
and
here
you
could
see
several
operators
in
the
basic
pi
calculus,
because
there
are
a
lot
of
a
lot
of
different,
like
versions,
a
lot
of
branch.
A
In
my
calculus,
for
example,
there
is
a
typed
pike,
it
goes
by
curriculus
used
for
some
different
purposes
and
so
on
so
on,
but
like
all
of
this
can
comprised
from
this
basics.
Yes,
you
have
services
or
in
a
term
of
pi
calculus
names
that
should
be
called,
and
you
could
pass
like
data
to
this
names
or
channels.
Another
major
you
have
combinators.
A
So
here
you
could
see
the
last
one
is
a
bar
or
pipe.
Yes,
remember
the
question
about
par
in
the
aqua
that
like,
if
you
call
functions
on
par
and
call
second
function,
it's
how
it
like
could
be
written
in
the
pycalico
syntax.
Yes,
here
we
could
see
bar
and
this
bar
is
represented
as
a
power
instruction
on
aqua
and
what
about
like
construction
themselves?
A
Air
has
a
few
instructions
for
14
instructions.
There
are
not
all
of
them,
but
probably
the
most
important
one
and
let's
like
dig
into
each
instruction,
so
the
first
one
is
called
it
was
already
presented.
A
Yes,
it
has
like
a
syntax
where
you
should
describe
origin,
yes
or
location
exactly
so
pure
id
service,
name
and
function
name,
and
also
you
should
specify
arguments
and
the
probably
output,
yes,
so
names
that
could
be
used
outside
the
school
instruction
and
construction's
very
powerful.
It
not
just
call
service
allocated
on
a
pure
idea,
but
it
also
like
move
execution
fall
to
this
pure
id.
A
A
The
third
one
is
a
parallel,
so
what
does
it
mean
to
be
executed
in
the
parallel
and
sequentially?
So
dmitry
already
said
in
his
talk
that,
like
power
produces
my
imagine
picture
when
akovium
produces
list
of
peers,
as
in
in
this
scheme,
the
first
like
after
execution
of
the
simple
script,
only
the
first
like
instruction
in
siku,
will
be
executed,
so
they
will
be
executed.
One
by
one
in
a
parallel
of
2b
will
be
executed
in
a
list
of
peers
will
contain
two
period
client,
a
and
coin
b.
A
In
the
same
time,
on
this
example,
only
one
okay,
this
next
one-
is
not
an
instruction,
but
it's
one
does:
yes,
it's
a
way
how
we
could
point
into
a
concrete
value
or
concrete
sub
value
in
our
value,
so
actually
inside
here
we
use
json
based
values
and
we,
like
could
use,
wonders
just
to
specify
past
a
concrete
value
in
adjacent
value.
A
Yes,
it
works
as
you
expect
so,
for
example,
hero.
Imagine
that
users
is
array
and
we
want
to
have
pure
id
of
the
first
element
in
array.
So
for
this
one
you
should
specify
lambdas
like
this,
so
it's
really
really
easy,
and
is
this
one
like
inspired
by
lum
de
calicos
and
we're
also
probably
inspired
by
category
theory?
Yes,
because
it's
also
has
like
a
storm
and
a
category
theory.
A
A
I
will
show
you
later,
why
like,
where
it's
needed,
why
we
need
like
up
and
up,
is
not
inspired
from
by
calculus,
but
like
it's
like
from
probably
conventional
wisdom,
yes,
that
we
need
to
have
a
way
to
like
grab
a
value
from
our
sub
value,
from
a
value
and
put
it
to
another
value
without
calling
service
and
it's
needed
to
preserve
tetroplets.
A
A
So
on
here,
you
can
see
that
we
like
moving
execution
to
the
initpro
id.
We
have
literal
like
need
pro
id
in
the
air,
and
you
could,
for
example,
lock
this
here,
and
we
have
also
literal
for
last
error
that
so
last
year
is
like
a
really
last
hero.
That
was
just
bubble
up
and
we
could
log
it.
For
example,
if
you
want
next
pair
of
instruction,
is
a
matching
mismatch.
A
A
So
the
next
one
is
a
bit
complex
is
a
fold.
So
fault
is
the
white
way
how
you
could
iterate
our
array,
it's
inspired
by
also
by
pi
calculus
by
lambda
calculus,
but
mostly
by
one,
the
calculus,
because
along
the
calculus,
it's
more
natural
to
have
concept
of
a
fixed
point
of
operator.
So
it's
usually
it's
a
way
how
you
could
have
a
recursion
in
on
the
calculus,
so
like
fault
iterates,
our
iterable?
A
A
A
We
put
it
in
the
variable
called
users,
and
then
we
like
in
users-
sorry
it's
inconvenient
here
so
just
forget
about
this
oneness
and
what
you
might
know
that
we
don't
have
this
one
this
and
we
trade
ourselves
users
like
saving
current
user
in
this
iterator
code.
A
U
and
execute
this
instruction
with
this
value
this
this
is
iterator
and
this
iterator
could
be
used
inside
this
instruction
anywhere,
and
this
one
is
next
is
like
idea
of
switching
yes,
it's
ideal
of
a
fixed
point:
combinator
when
you
just
move
iterator
to
the
next
one
to
the
next
value
in
the
list
and
the
code
recursively
next
could
be
located
anywhere.
A
So
in
this
example,
you
have
something
that
could
be
called
left
fold
in
a
functional
programming
languages,
and
you
imagine
that
if
you
switches
this
to
instruction
and
in
this
way
that
next
would
be
the
first
one,
then
you
would
would
have
right
fault.
Is
that
what
you
start
from
the
end
and
would
it
trade
through
the
beginning?
A
A
And
dig
like
a
bit
more
into
details,
so
let's
talk
first
about
values
as
dimitri
already
presented
in
aqua.
We
have
scours
and
streams
scours,
they
are
fully
consistent,
they
are
json
based
and
they
could
be
used
in
any
any
instruction
because
they're
consistent,
meaning
that,
like,
if
you
run
script
on
every
peer,
this
cover
will
have
the
same
value.
Why
I
mean
this
this
sorry,
this
variable
would
have
the
same,
the
same
value
like
during
the
execution
of
the
script,
but
streams
they
are
much
more
complex.
A
A
So
by
conicalization
I
mean
that
you
could
say:
oh,
I
won't
stream
like
exactly
stream
on
the
value
or
sorry
on
the
current
peer
to
be
fixed
and
we
could
convert
it
to
a
scour
with
a
special
instruction
called
clinicalization,
and
without
can
equalization,
streams
could
be
used
only
by
a
few
instructions,
because,
like
execution
of
aqua
vm
should
be
convergent,
you
should
be
able
to
merge
values
and
otherwise,
like
it
would
be
really
possible
and
it
wouldn't
be
converged
conversion
because
it
wouldn't
be
deterministic
anymore
and
like
in
maybe
yeah
in
two
weeks
there
will
be,
a
restriction,
will
be
merged
and
stream
would
be
used
only
by
fault
and
the
clinical
ice
instructions.
A
So
and
let's
dig
how
instruction
instructions
are
executed.
So
actually
it's
very
basic
and
when
you
like.
A
A
We
also
represented
here
skipped
as
a
graph
and
actually
it's
a
graph,
not
a
tree,
because
it's
possible
to
write
two
streams
that
were
iterated
on.
So
there
is
a
there
could
be
cycle
graph
so
and
consider
this
example
that
we
already
seen
with
the
fault
instruction-
and
here
you
can
see
that
there
is
a
cycle
yes
and
the
vertices
here
represent
instructions
and
connection
between
them
represent
like
connection
between
instructions.
A
So
very
simple
and
akovium
on
each
like
step,
tries
to
execute
all
sub
graphs
like
it
tries
to
do
like
traversal
and
tries
to
cover
all
subgraph.
Oh
sorry,
o
graph
and
like
mat
all
values
over
systems
as
graph
as
possible.
According
to
the
rules
of
instructions
and,
for
example,
imagine
like
three
instruction:
she
cook
soar
and
par
yes
and
secure
the
like
the
right
subgraph
of
security
will
be
executed
only
if
the
left
sub
graph
was
already
executed
without
errors.
A
That
is
how
sequentially
works
so
like
in
this
example,
this
sub
graph,
the
entire
subgraph,
would
be
executed.
Only
this
one
left
one
was
already
executed
without
errors
and
in
this
example,
in
a
par
example.
Yes,
all
these
subgraphs
will
be
executed,
like
independent
on
each
other,
that
the
how
parallel
work
that
that's,
how
like
it's
possible
to
achieve
parallel
execution
and
parallel,
sending
to
different
peers
and
xor
like
as
you
expected
right,
sub
graph,
would
be
executed
only
on
the
left
side
graph.
A
There
was
a
error
or
exception,
so
we're
moving
to
the
like
really
complex
topic.
I
wouldn't
cover
it
in
details
because
it
deserves
separate
talk,
but
I
will
say
some
word
and
show
some
slides
so
like
it's
important,
that
there
is
no
any
saved
entry
point,
meaning
that
execution
of
rqm
starts
from
the
very
beginning
each
time.
So
when
script
comes
to
aqua,
vm,
it
executes
from
the
very
beginning
from
the
root
of
the
graph
to
the
end,
to
the
one
that
could
like
traverse
on
a
current
step.
A
But
the
problem
here
is
that
instruction
can
be
executed
several
times,
but
it
wouldn't
it
wouldn't
be
like
it
would
make
any
sense,
and
to
avoid
this,
we
have
so-called
execution
trace.
That
is
the
main
part
of
data.
So
remember
this,
like
aquavium
box,
with
arrows
where
state
comes
to
aquarium
and
aquarium
produce
new
state-
and
here
like
state,
is
data
and
the
main
part
of
the
data
is
the
execution
trace
and
the
execution
trace
is
just
array
of
like
such
values.
A
So
here
you
can
see
that
there
are
four
instruction
in
this
enum.
We
like,
we
don't
save
results
of
all
instructions.
We
save
only
four
of
them
they
like,
and
only
fourth
of
them,
they're
required
to
be
saved.
Actually,
like
maybe
sorry
yeah,
if
you
have
any
questions,
just
interrupt
me
in
any
moment
and
like
probably
the
most
simple
one
is
a
bar,
so
par
just
save
two
numbers.
A
A
And
like
again,
this
picture
so
when
akovium
x
like
execute
code,
it's
not
executed
like
in
a
place
like
it
just
saves
of
core
parameters
and
pass
it
back
after
the
end
of
all
execution
as
a
caller
call
request,
and
then
it
expects,
as
already
said,
to
obtain
results
of
the
question
back
on
some
moment
like
eventually
when
they
would
be
prepared
by
service,
and
I
like
how
it
works.
It
works
based
on
the
pure
idea.
Imagine
that
like
so,
he
has
already
said
all
pearson.
A
Our
network
has
aqua
vm
and
if
period
d
is
equal
to
the
current
node
pred
that
also
passed
to
the
aquarium.
As
a
argument
then,
like
this
parameters
are
captured
and
passed
back
as
a
result
from
aquarium,
if
not
it
just
passed
as
the
next
pure
ideas.
Yes,
it's
like
it's.
A
A
Already
sorry,
and
like
also
during
the
execution
of
script,
aquavia
merges
this
two
data
that
passed
in
the
aquarium,
current
data
and
previous
data,
and
the
result
is
in
using
new
data.
That
also
should
be
the
toaster
return
and
passed
should
be
passed
back
to
aquarium.
As
a
previous
data,
and
here
we
could
see
a
last
slide
on
this
topic,
it's
how
merge
works.
A
So
it's
really
it's
the
simplest
example,
but
it's
just
shows
how
it
works.
So
imagine
that
we
have
previous
state
that
contains
par
and
like
on
the
left,
sub
graph
of
par.
We
have
one
instruction
call
and
the
right
one
instruction
call
yes,
this,
like
on
previous
data
par
like
s11,
and
there
is
only
is
how
linearization
of
graph
works
yes
and
on
current
data.
Imagine
that
we
have
more
states.
A
Yes,
like
this
states
like
remain
yes
from
the
left,
sub
graph,
more
states
on
the
right,
subgraph
and
here
could
see
the
result,
how
it
merged,
and
this
one
see
the
core
results.
They
just.
A
A
The
co
results
so,
and
you
could
see
that,
like
during
execution
of
each
result,
there
is
a
like
complex
process
when
you
merge
data
like
current
the
previous
data
and
the
result
is
a
new
data
that
comes
from
the
interpreter,
and
this
new
data
should
be
passed
then
to
the
other
peers,
and
the
last
topic
is
a
topic
like
more
maybe
mathematicial,
mass
properties
of
aqua
vm,
so
aqua
vm
could
be
considered
as
a
so
when
you
have
one
of
these
calls
that
are
asynchronous
so
that
require
to
go
to
the
network.
A
We
can't
stop
it,
we
collect
parameters
of
this
call
and
then
save
it
somewhere,
and
then
it
will
be
returned
to
a
node
as
a
as
a
call
request.
We
we
we
don't
stop
it.
C
And
what,
if
you
you,
don't
get
the
result?
So
you
don't,
then
you
don't
okay,
so
I
will
only
trigger
a
new
vm
process.
Let's
say
when
I
receive
the
so
I'm
not
affecting
the
language
of
the
key
right.
Yes,
okay,
so
immediately
that
I
actually
hear
some
computation
that
the
other
never
answers.
We
just
eventually
got
reflected,
but
yes,
okay,
yeah,
but
then
you
froze
at
the
end
in
some
way.
Okay,
so
you
just
like
you
have
the
context.
You
store
the
context
and
then
you
initialize
yourself.
A
We
know
the
referrals,
probably
we
shouldn't,
we
don't
like
traverse
dive
into
this
sub
graph.
We
just
stay
on
this
like
line
on
this
call
and.
A
A
A
Yeah
yeah,
I
think
I
think
we
need
considerate.
So
yes,
it's
something
similar
to
this
was
in
our
plans
but
like
now
it's
doesn't
work
like
this.
Okay,
let's
move
to
the
last
topic.
If
you
don't
have
other
questions
about
like
about
some
invariance
of
aquarium,
is
a
function
so
actually
aquarium
could
be
considered
as
a
manoid.
A
Yes
or
here
you
could
see
the
exact
how
health
code
it's
left,
banned,
regular
monoid,
it's
there
is
a
theory
behind
it
and
remember
that
I
said
that
we
don't
have
serious
but
seriously
like
in
this
series
you,
like
so
actually
crdt,
usually
based
on
similarities.
A
Yes
and
usually
third
dtc
is
commutative
operation,
but
in
our
way
ammanoid
is
not
not
a
commutative.
It's
based
in
a
series
based
on
a
green
solder
and
they
itself
based
on
the
left
band,
regular
monomet.
It
doesn't
matter.
What
is
it
for
this
talk,
but
why
just
if
to
make
like
it
would
make
any
sense
and
just
why.
A
So
like,
and
if
you
remember
like
manoy,
it
is
a
like
set
an
operation
and
the
aquarium
as
a
function
is
a
closet
on
the
set,
meaning
that
it's
always
retorn
data.
So
here
you
could
see
the
signatures
there.
The
result
is
and
to
return,
interpreter
outcomes
that,
like
internally,
contain
data.
So
even
if
there
is
a
error,
then
also
data
will
be
provided
by
the
aquarium,
so
in
this,
in
this
sense
is
closed
on
x.
So
it's
forms
magma
like
following
the
barbecue
then
like
is
the
most
important
properties
for
every
distributed.
A
A
The
third
properties
is
a
natural
element,
that's
necessary
for
the
separation
to
be
sorry
to
this,
for
this
operation
and
the
set
to
be
manoid,
and
we
have
neutral
element.
Why?
Why
it's
important
because,
like
you,
have
have
a
great
question
about
civilization
of
result
and
how
result
passed
back
to
akovium-
and
here
is
a
like.
A
If
you
dive
a
bit
in
the
details
like
you,
could
ask
do
we
need
to
pass
current
state
again
for
this
result
or
not,
and
the
answer
is
not
so
imagine
that
you
pass
like
current
state
from
a
network
and
previous
state
that
was
saved
on
appear
and
it
works
as
a
mid
operation
on
a
lattice.
Yes,
it
saves
in
your
new
state
and
then
you
shouldn't
pass
current
data
again,
for
so
imagine
that
your
co
result
is
ready
and
then
you
need
to
pass
it
back
to
aquarium.
A
In
this
case,
you
shouldn't
provide
current
state,
and
in
this
case
we
have
natural
element,
it's
just
empty
data
and
you
could
provide
empty
data
as
a
current
state
and
also
you
could
provide
other
current
data
or
equal
to
this
or
just
come
from
a
network.
C
A
If
there
is
a
network
packets
belong
to
this
particle
comes
to
node,
then
it
should
be
postponed
until
this
part,
this
network
packet
or
this
state
is
executed.
So.
C
You
kind
of
have
the
semantic
of
say.
I
mean
if
I
have
a
particle
that
conflicts
with
some
state.
It
will
wait
like
it
would
wait
for
the
previous
one,
not
if
it's
missing
the
date
it
will
just
exit
and
continue
when
oh,
it's,
this
variable
like
feeling
that
yeah
you're,
mentioning
basically
with
firewall.
C
C
Are
you
even
sure
the
hashes
will
be
different.
A
As
I
understand
the
question
correctly,
so
the
execution
they're
divided
according
to
the
particular
id
yeah,
and
there
is
a
queue
so
alexey
knows
better
because
he's
developer
of
node
how
magic
works
behind
the
cues
but
like
there
is
excuse
for.
As
I
understand
for
each
particular
thing,.
B
C
B
C
One
is
if
you
do
go
to
the
right
of
hashtag
all
the
calls
in
the
state.
Then
you
have
a
really
good
verifiability
scheme,
because
then
you
can
just.
B
Sample
some
of
the
states
and
recompute
the
entire
call
from
start
to
end.
Yes,
and
you
have
a
really
nice
probabilistic
model
for
verifying
the
competition.
That's.
B
A
We
don't
have
signatures,
but
if,
when
we
have
it,
then
we
will
check
it
like
every
time
on
our
repair
and
also
then
we
want
to
introduce
your
knowledge
proofs
right,
not
to
check
it
like
every
time,
but
so,
but
the
like
process
will
be
like
step
by
step.
You
want
to
start
your
signatures,
so
then
we'll
introduce
you
another
groups,
but.
B
And
you
should
also
check
out
it's
a
project
that
we
have
around
very
complete
list:
oriented,
zero
knowledge
language,
so.
B
You
can
do
any
kind
of
lisp
structure,
come
double
ipod
data
and
then
you
can
use
your
knowledge
groups
on
all
of
that.
Competition.
A
Yeah-
and
you
know
when
I
fly
to
iceland-
I
I
have
just
talked
like
details
talk
about
ipod,
so
it
was
first
time
for
me.
I
wasn't
the
word
before,
but
when
I
thought,
when
I
seen
it,
it
was
like
very
similar
to
what
we
were
doing
because,
like
from
the
inner
perspective
of
what
the
author
called
data
model,
it's
very
similar
to
interface
types
over
some
interface
types,
because
there
is
a
rules
and
also
author
codes
that
I
want
to
have
by
code
instruction
in
ipod
to
like
encoding
it
and
now.
A
Ipod
is
similar
to
how
interface
type
works
currently
involve
assembling
standards.
It's
like
communicalization,
meaning
that,
like
there
is
a
fixed
way
how
data
could
be
lowered
or
lifted
from
different
format
and
from
inner
perspective.
It
works
as
a
data
in
aquavium,
because
from
inner
perspective
type
is
considered
as
a
graph,
and
also
we
have
the
same
in
aquarium
so
probably
as
it
makes
sense,
and
we
could
like
think
how
it
could
be
integrated.
B
C
A
Okay
and
this
one
is
like
again
image
of
how
it
internally
works
at,
like
this
core
request
passes
to
aquavium
and
we
provide
the
like
empty
state,
because
we,
the
meat
on
the
our
simulators
based
on
this
love
band.
Regular
monoit
was
already
done
and
we
don't
need
that
anymore
and
the
last
property
is
that
this
function
is
not
commutative.
A
It
means
that,
like
this,
crdt
is
not
just
usual
series
just
here
that
you
like
and
like
peer
saves
this
new
state
locally
each
peer
for
going
to
each
particle,
and
then
it
passes
back
as
a
previous
state.
But
this
state,
like
the
order
here,
is
necessary.
So
if
your
switch
is
currently
in
previous
data,
the
result
will
be
different.
A
That's
how
like
streams
works
internally,
we
want.
We
wanted
to
have
a
separate
call
about
that,
but
we
like
we
decided
that
probably
it's
better
to
discuss
how
it
could
be
integrated.
So
it's
deserve
a
separate
topic,
so
I
won't
say
any
more
about
that
and
tetraploids
was
already
covered
by
dimitri.
A
But
like
again,
the
idea
was
imagine
that
we
have
this
simple
script:
that
just
call
some
authorization
service
and
there
is
a
function,
is
authorized
and
there
is
some
altercation
of
the
authorization
result,
and
there
is
another
service
that
called
log
storage
and
we
want
to
delete
some
work
based
on
work
id
and
some
authorization
result,
and
here
that,
like
this
variable,
there
is
also
the
top
left
will
be
passed
and
the
triplet
contains
four
fields
that
describe
the
origin.
A
A
Yes,
your
misconception
because,
like
I,
wouldn't
recommend
anyone
to
use
jason
pass,
especially
in
rust,
it's
unbelievable
experience
and
yeah.
It's
how
the
request
works
here,
pass
to
service
and
servers
could
check
what
is
the
origin
of
this
variable,
and
this
is
last
slide.
So
all
code
is
open
source.
You
could
find
and
buy
these
links.