►
From YouTube: Aqua language intro - @alari - Aqua and IPFS
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
This
is
going
to
be
an
aqua
101
introduction
to
Aqua
and
I'm,
going
to
speak
about
everything
related
to
Aqua,
but
just
little
so
I
won't
go
too
deep,
but
if
you're
interested
in
anything,
we
will
either
have
other
talks
later
by
Alexi
and
Mike,
where
we
can
discuss
like
anything
so
the
agenda,
first
of
all,
I,
will
tell
about
possibilities
what
you
can
do
with
aqua
and
for
what
purposes
it
was
designed
and
like
what
what
we
had
in
mind
designing
it
then
syntax
Basics,
what
it
looks
like
with
the
special
in
the
language
itself,
then
completion
targets
and
what
it
looks
like
when
it's
compiled,
where
you
can
use
it,
what
it
requires
from
the
peer
a
little
bit
then
performance
considerations,
not
strict
estimations,
just
reasoning
about
performance,
some
reasoning
about
security
and
finally,
plans
for
the
future
of
aqua
and
I.
A
Think
that
you
can
interrupt
me
if
you,
if
you
need
at
any
moment,
if
not
also
okay,
so
possibilities,
we're
aquafits
Aqua
is
made
for
zero
trust
coordinator
free
distributed
workflows.
So
if
the
workflow
is
not
distributed,
if
you
can
have
a
centralized
coordinator
node,
if
all
peers
are
trusted,
probably
Aqua
doesn't
fit.
But
if
you
have
these
requirements,
I
don't
know
any
any
other
solution.
To
be
honest,
if
you
know
some,
please
tell
me
so
this
is
the
niche
of
aqua.
A
Aqua
tries
to
move
computations
closer
to
data,
so
it
expresses
where
what
should
be
executed
and
it
tries
to
minimize
unnecessary
round
trips.
So
if
you
don't
need
a
reply,
you
don't
need
to
reply.
If
you
can
avoid
some
hops,
then
Aqua
will
try
to
help
you
with
that
and
with
this
you
can
do
distributed
algorithms
and
think
about
distributed
algorithms
into
different
layers.
A
One
has
a
low
level
like
protocols
in
lip,
P2P,
meaning
of
the
word
like
DHT
or
organized
soft
networks,
or
create
a
heterogeneous
network
with
many
different
algorithms
working
on
the
same
time.
That's
basically
about
infrastructure
and
also
Aqua
could
be
useful
for
delivering
user
experiences
extracting
the
value
from
different
distributed.
Algorithms
sub
networks,
parts
of
heterogeneous
Network
to
provide
the
value
for
the
user,
like
with
the
Lambda
or
step
functions.
A
About
about
the
language
design
goals,
first
of
all,
we
want
to
focus
on
execution
flow,
so
we
want
to
abstract
out
computations
delegate
the
computations
to
the
hosts
or
to
the
peer
so
that
they
can
be
implemented
by
some
other
tool
approach.
Anything
virtual
machine,
Docker
container,
anything
like
that.
A
Then
we
want
to
express
the
distributed
control
flow,
and
this
topic
is
quite
General
and
I.
I
cannot
list
all
the
distributed
protocols
beforehand
and
say
these
ones
are
good
and
we
want
them
and
all
the
others.
We
don't
care.
So
that's
why
we
took
Pi
calculus
as
the
foundation,
because
you
can
express
anything
with
pi,
calculus
and
aqua.
A
Fundamentally,
it's
a
syntax
sugar
above
the
Spy
calculus
based
a
set
of
instructions,
so
everything
should
be
doable,
but
for
the
language
you
want
to
express
them,
so
the
syntax
should
allow
it
and
we
want
to
abstract
algors
out
using
some
type
definitions
like
to
say
we
want
to
have
a
function
that
provides
us
a
sub
Network
sub
network
is
a
function
from
string
to
a
set
of
peers,
and
today
we
don't
want
to
decide.
We
don't
want
to
coin
that.
This
is
the
algorithm
to
select
sub
networks.
Anyone
can
decide
with
this
assumption.
A
B
A
For
me
is
super
important.
I
want
to
have
fun
so
I
like
language
like
Elm
and
Scholar.
Three,
it's
not
like
L,
not
like
scholar,
three
I,
don't
like
python.
To
be
honest,
so
it
looks
like
python,
but
it
shouldn't.
So
that's
it.
A
What
what
it
looks
like
about
data.
So
we
have
this
computations
control
flow,
algorithms
and
fun,
maybe
mixed
so
about
the
data.
A
We
decided
to
use
a
webassembly
interface
types
specification
to
express
computations
and
that's
why
we
took
the
basic
definitions:
the
definitions
of
basic
types,
primitive
types
from
webassembly
interface
types.
So
we
have
a
structures,
a
race,
similar
things
we
can
express
them
this
way
and
for
the
services
as
a
group
of
functions.
A
So
that's
about
data
is
inter
interoperable
with
a
web
assembly,
but
also
with
a
relax
it
type
checking
you
can
use
just
Json
with
that
and
like
call
JavaScript
or
anything
anything
else
functions.
The
workflow,
this
distributed
control
flow
is
organized
in
functions.
We
have
function,
type
definition,
which
is
basically
some
function,
name,
arguments
and
return
type
arguments
could
be
data
and
they
also
could
be
an
arrows.
A
So
here
we
have
an
arrow
from
two
arguments
to
nothing,
and
then
we
have
indentation
based
body
of
the
function.
That
looks
somehow
like
this.
In
this
case,
we
have
this
round
trip,
we
have
the
return
type
and
finally,
we
need
to
return
something.
So
you
can
emit
the
return
type.
Then
you
will
have
no
hops
back
to
the
initial
tier
to
to
the
requester
like
remove
this.
This
part.
A
A
Then
the
special
thing
for
a
distributed
workflows
is
a
topology.
So
we
have
this
on
expression
with
the
Balkan
side
and
it
basically
says
that
all
what's
inside
should
be
executed
on
this
pier.
So.
A
What
what
would
happen
with
this
block
before
the
block
execution
will
be
stopped?
The
package
will
be
serialized
sent
on
the
wire
to
disappear.
It
will
get
it.
This
realize,
run,
Aqua
VM,
run
these
functions
and
then,
when
the
block
ends,
probably
something
else
should
happen.
In
this
case,
we
have
another
on
block,
so
the
topology
will
be
inserted
here
automatically,
and
we
have
this
on
Via
block
to
say
that
to
get
to
this,
pier
you
need
to
to
walk
through
through
another
Pier.
A
So
relaying
in
aqua
is
not
a
part
of
some
fundamental
protocol,
it's
just
a
part
of
a
script
and
you
can
use
many
release.
If
you
want
just
in
the
code,
you
can
make
them
optional.
You
can
have
many
like
organize
them
as
a
chain,
and
this
topology
will
be
captured.
If
you
need
it
and
you
you
just
you
just
use
it.
A
Another
topic
is
parallelism.
We
have
some
different
expressions
for
parallelism,
one
is
par,
which
means
that
that
this
expression
must
be
done
in
parallel
with
with
that
expression,
we
have
co.
That
means
that
I
just
want
to
to
do
this
in
parallel
in
far
and
forget,
Manner
and
I
don't
have
to
wait
to
anything,
and
we
have
drawn
expression
to
wait
for
some
data
to
be
present
so
that
we
can,
in
this
case
we
fork
and
then,
and
then
we
join
actually
drawing
is
done
simply
by
data
using
yep.
A
The
fact
that
that
first
line
doesn't
have
R
means
that
it
finishes
before
yeah.
Why
does
the
second
winding
hard
personal
doesn't
well
because
that
was
derived
from
PI
calculus,
where
you
have
one
process
bar
and
the
second
process,
so
this
is
one
process
bar
in
the
second
process.
They
are
in
parallel.
C
And
then
okay,
so
every
time
you
add
another
parallel,
it's
like
a
fight.
B
Which
means
that
you
it's
allowing
table
in
order
to
know
how
to
paint
right,
but
do
you
have
access
to
the
context,
meaning
like
I
may
establish
a
set
of
connections,
I
and
I?
Don't
want
to
Mark
a
specific
fear,
but
I
want
to
say
hey
the
first
year
of
my
routing
table
or
like
okay.
All
my
connections
would
that
be
possible
to
be
respect.
The
language
yeah.
A
So
Aqua
doesn't
Force
any
solution
about
how
to
choose
the
peer
to
run
executions,
to
run
competitions
or,
if
you
have
the
routing
table
efficiently.
It's
data.
If
you
have
open
connections
efficiently,
it's
a
state
of
the
pure.
You
can
provide
this
state
or
provide
this
data
to
Aqua
using
services.
C
B
Routine
table
or
anything
else,
but
that's
not
real
time
right-
is
that
as
this
script
is
executing,
the
context
is
not
updated,
which
means
that
if
the
routing
tool-
so
let's
let's
say
I,
don't
idle
connection,
I
load
my
enrollment
table
and
then,
if
you
appear
as
a
connection
in
mind
here,
so
there's
no
direct
communication.
There
are
no
events
yeah,
so
the
VM
is
isolated
right.
There's,
no,
real-time
events
between
the
execution
and
the
context
where
it's
executed.
C
C
B
C
At
all,
like
it's
real
time
in
the
sense
that
you
move
completely
and
you
do
everything
you
you
want,
but
there
are
no
like
right
now
there
are.
There
is
no
symptoms
for
receiving
events
for
years
right
away
like
from
from
operating
system,
but
we're
thinking
about
that.
Okay,
yeah,
I
I
was
just
wondering
like
how.
A
So
it
could
be
done
somehow
like
this.
You
have
function,
the
workflow
that
you're
going
to
run
and
as
the
first
line,
you
are
calling
the
local
service
the
local
function,
to
read
a
list
of
peers
as
a
value.
Then
you
take
like
the
first
peer,
for
example,
move
execution
here
and
do
something
this
peer.
Id
is
the
data.
It's
it's
a
value.
A
You
can
just
just
use
it
in
a
variable-
and
in
this
case
you
can
also
say
like
next
pure
I,
don't
know
your
ID,
and
here
you
can
say
next
year.
A
And
in
this
case,
you
abstracted
out
how
exactly
you
you
get
to
the
next
Pier
just
somehow,
but
it
will
be
executed
and
you
can
provide
some
service
to
it.
You
can
do
it
using
streaming
under
the
hood
with
drawing
spiral,
whatever
local,
not
local,
doesn't
matter.
So
it's
scriptable.
A
And
yeah,
you
can
have
some
context
of
the
request,
but
to
get
to
the
context
of
the
peer
where
you
currently
are.
Usually
you
need
to
call
some
function
of
the
service
to
read
the
data,
to
bring
this
data
into
aqua
and
to
use
it.
A
The
next
concept
is
loops,
we
have
for
Loop,
and
we
have
three
different
types
of
four
actually
is
four
sequential
four
that
waits
for
execution
and
then
goes
to
the
next
one.
If
there
was
no
errors,
we
have
four
par.
That
runs
execution
of
all
the
branches
in
parallel
and
we
have
four
try
that
it
rates
until
the
first
cycle
yields
something.
A
So
in
this
case
we
take
all
the
piers
and
do
do
the
calculations
on
in
parallel
and
for
for
Loops.
There
is
a
another
super
important
concept:
it's
the
Stream
yeah,
it
denotes
the
stream
and
the
stream
is
a
the
value
type
that
you
can
use
several
times
to
write
to
it.
A
It's
an
append,
only
crdt
data
structure.
A
Another
one
will
have
the
value
B
and
if
they
eventually
exchange
the
messages,
then
the
first
one
will
have
the
stream
a
and
then
B
and
the
second
one
one
will
have
B
and
then
a
so
that
the
head
of
stream
is
a
stable
and
the
beer
can
do
some
Logic.
On
top
of
that,
take
the
first
element
or
do
something
like
that.
A
If
you
need
to
stabilize
the
string
for
everyone,
there
is
Special
Operation
named
canonicalization
that
fixes
the
order,
as
it
was
seen
by
some
peer
writing
to
stream,
does
make
a
copy
of
data.
All
other
rights.
Making
the
copy
or
other
service
function
calls,
and
you
can
Loop
over
a
stream
doing
map
and
it
could
be
done
in
parallel
as
well.
A
So
you
can
react
on
new
data
using
for
Loop
on
top
of
the
stream
variable,
and
you
can
write
to
this
stream
variable
from
the
inside
of
the
for
loop
as
well
hand
back
pressure
and
all
this
stuff.
So
this
concept
is
super
powerful.
A
Only
streams
can
escape
the
for
Loop,
so
the
namespace
inside
the
for
Loop
is
isolated.
You
cannot
use
these
variables
outside
because
it's
not
clear
which
one
you
want
to
use,
so
only
only
the
streams
can
be
used,
so
that
was
the
verb.
Brief
overview
of
the
syntax.
A
A
So
about
compilation.
Aqua
is
more
or
less
Rich
language,
but
it
compiles
to
something
like
like
this.
It's
called
ear,
Aqua
intermediate
representation.
This
is
a
derived
from
PI
calculus.
It
has
a
some
branching
operations
or
sequential
parallel.
We
don't
have
parallel
here
so
for
branches.
Only
one
operation
to
get
from
Aqua
VM
to
The
Host.
It's
called
and
looks,
looks
like
this.
If
you
need
to
debug
Aqua,
probably
you
will
need
to
take
a
look
on
this
to
understand
what
exactly
happens.
A
What,
if
you
want
to
write
Scripts,
then
writing
this
is
super.
Super
annoying
I
would
say
the
most
interesting
thing
right
now
is
the
goal
instruction
which
looks
like
this:
it
has
the
peer
ID
where
it
executes,
then
a
couple
of
service,
ID
and
the
function
name.
A
Then
some
list
of
arguments
might
be
empty
and
if
we
want
to
use
the
value
from
the
service
and
spend
some
space
in
the
data
for
the
value
we
can
export,
the
results
in
some
in
some
variable,
so
call
is
the
only
instruction
that
moves
an
execution
to
the
peer.
So
when
you,
when
the
aqua
VM
see
the
call
instruction
and
the
peer
ID
differs,
then
it
realizes
that
execution
should
move
further.
A
A
And
probably
Alexa
saw
something
about
how
how
it
looks,
but
pure
implementations,
actually
peer.
Implementation
is
just
three
things:
I
forgot
to
add
a
picture
here,
it's
lipitupi
connection,
pool
it's
a
pool
of
Aqua
VM
and
something
to
execute
whatever
you
like.
We
have
two
implementations
of
the
peers.
One
is
in
JavaScript
and
typescript,
and
for
JavaScript
and
typescript
aqua
workflows
looks
like
a
well-typed
asynchronous
functions,
so
you
write
code
in
aqua,
compile
it,
and
this
is
just
a
sync
Funk,
with
all
all
the
types
with
the
promise
as
the
return
value.
A
If
you,
if
you
want
it,
if
you
want
to
provide
some
callbacks
inside
the
function,
you
just
use
JavaScript
callbacks,
but
actually
all
of
them
are
mapped
to
the
service
calls
and
so
on.
If
you
want
to
provide
to
show
expose
some
code
to
JavaScript
peer,
you
use
you
just
create
a
JavaScript
or
typescript
object.
You
also
have
type
definitions
for
that
generated
Alexa.
Also,
for
the
rest,
we
don't
have
as
far
as
I
know.
A
Client
implementation,
it's
on
the
server
and
the
easiest
way
to
provide
the
code
using
rust
is
to
register
services
using
Marine
webassembly,
but
you
also
can
expose
native
rust
as
well.
If
you
want
to
to
know
how
ask
us
please,
and
also
you
can
use
Aqua
just
with
aqua
using
aqua
CLI.
Oh
I
forgot
to
to
put
the
line
about
how
to
install
it,
so
it
works
not
very
fast.
It
could
take
a
couple
of
seconds
for
the
request.
A
That's
because
every
time
It
prepares
the
compiler
compiles
Aqua
to
ear
connects
via
a
lipitupita
network
makes
the
request.
So
it
takes
takes
time
and
if
you
want
to
have
something
more
optimal,
probably
you
don't
want
to
use
like
this
CLI
compiler,
but
you
want
to
compile
to
JavaScript
or
something
like
that
and
use
the
compiled
code.
A
Performance
just
considerations,
nothing,
nothing,
strict
topology
hopes,
Network
hops
take
time,
so
you
need
to
be
careful
about
the
network
hops
and
if
you
have
any
parallel
branches
of
code,
then
it's
not
always
necessary
to
make
hops
back
from
like
to
to
get
the
response
from
the
parallel
branch.
Aqua
compiler
works
as
far
and
forget
by
default.
No
acknowledges
no
responses.
A
A
Join
Behavior
must
be
explicit.
You
need
to
show
that
you
care
about
something
from
this.
This
branch,
but
actually
Aqua,
does
almost
nothing
about
the
topology.
It
depends
on
the
algorithm.
If
you
do
a
stupid,
algorithm
performance
will
be
where,
if
you
do
something
fancy,
it
will
be
awesome
verification.
A
It
has
two
parts,
one
is
immutable:
it's
the
code
and
some
headers
like
signatures,
particle
ID
and
such
stuff,
and
also
we
have
data
every
time
the
service
call
happens.
A
This
data
grows
so
it
grows
like
linearly
with
during
the
execution.
A
Every
time
when
the
particle
gets
to
to
the
pier
all
the
code,
all
the
ER
code
is
replayed
by
Aqua
VM
from
the
very
beginning
until
the
calls
with
no
results
are
found.
A
So
we
have
the
verification
of
all
the
previous
flow
and
we
check
that
the
right
Piers
got
the
right
data
from
the
right
sources
provided
the
result-
and
this
result
wasn't
checked-
wasn't
changed
by
anyone
else
so
that
we
can
have
the
ground
under
our
feet
when
we
write
the
code,
but
it
takes
some
some
time
then,
as
execution
Trace
grows
and
we
have
like
bandwidth
pressure,
the
ear
script
and
the
header
is
always
attached
to
the
particle,
so
it
always
so
serialized
to
the
wire
sent
received
and
so
on.
A
While
execution
happens,
we
don't
have
garbage
collection
yet
for
the
consumed
data
is
planet
but
not
implemented,
so
it
only
grows
and
also,
if
you
need
some
logic
like
array
sorting,
if
you
like,
do,
for
example,
in
aqua,
you
need
to
reorder
the
the
list
of
possible
next
peers
and
it
could
be
not
efficient
for
the
data,
because
currently
this
rewarding
reordering,
if
it
happens
outside
of
RPM,
it
adds
to
the
data
so
yeah
and
every
response
should
be
signed
by
the
peer
for
tamper
protection,
which
also
consumes
bandwidth.
A
Finally,
the
effect
of
the
pier
performance
depends
on
peer
implementation
details
and
this
is
actually
outside
of
Aqua,
but
the
experience
depends
on
this,
like
what
format
is
used
for
the
wire,
how
exactly
we
serialize
it?
How
exactly
the
call
is
done?
The
call
the
like
how
exactly
do
you
write
to
the
socket
read
from
the
circuit,
all
the
stuff
it
matters,
but
it
Aqua
has
nothing
to
do
with
that.
A
Usually,
you
need
to
optimize
just
one
place
when
you,
where
you
send
the
particle
and
another
place
where
you
receive
it,
but
that's
outside
of
Park.
One
service
calls
how
exactly
the
control
passes
stack.
Vm
goes
to
the
host
goes
back.
How
exactly
the
call
is
dispatched
by
the
peer
how
the
queues
are
organized
on
the
pier
it's
also
outside
the
arc
VM
as
yeah.
Every
time
data
gets
out
from
aquvm
deserialized
serialized
bus
to
like
something
happens
it
and
its
matters
and
parallelism.
We
have
local
parallelism
on
on
a
single
period.
A
You
can
call
different
services
in
parallel
and
then
you
have
responses
and
there
could
be
different
strategies
how
you
handle
these
responses,
and
it
also
has
the
effect
on
performance.
A
Yeah,
what
could
be
improved
and
what
we
plan
to
improve?
It's
binary
error.
Currently
we
send
these
strings,
it
simplifies
debugging,
but
it's
not
very
efficient.
The
data
formats
also
should
be
changed
so
currently
it's
a
serialized
Json
might
be
something
better
metadatication.
A
If
we
have
evidence
that
the
script
was
already
on
some
peer,
we
can
skip
this
script
and
use
the
hash
of
the
script
inside
instead
of
the
script
so
optimize.
This
way
we
plan
to
move
more
operations
inside
the
arc
VM
to
make
them
cheap
so
that
every
peer
can
reorder
the
stream,
for
example,
to
avoid
copying
the
data
escaping
the
aqua,
VM,
checking
the
data
and
so
on.
A
So
it
also
makes
sense,
hack,
VM
and
the
webassembly
interface
types
optimizations
garbage
collection
for
consumed
data,
as
we
can
track
the
last
time
when
the
data
is
needed
in
the
call
instruction.
We
actually
can
garbage
collect
it,
but
currently
we
don't
do
it
a
few
words
about
security,
just
a
few
really
if
you
signatures
and
tetroplets
proofs
of
data
origin.
A
So,
okay,
we
have
the
immutable
part
of
the
particle
and
it's
signed
by
the
initial
peer.
The
one
who
sent
the
request,
no
zero
knowledge
magic
here,
yet
no
privacy,
preserving
protection
and
so
on,
unfortunately,
but
it
is
as
it
is
so:
okay,
you
can
check
it,
and
then
we
have
the
call
instruction
again
and
it
has
pure
ID
service,
ID
function,
name
and
some
arguments.
What
can
be
a
reason
about
the
arguments
at
the
moment
when
we
execute
this
Construction?
A
We
can
check
the
sources,
because
the
the
only
way
how
this
variable
pref
in
this
case
can
appear
in
aqua,
is
by
calling
some
other
call
instruction
with
some
peer
service,
ID
and
function
name,
and
we
can
check
that
this
triplet
is
expected.
For
example,
if
you
have
an
authorization
service
on
the
same
peer,
for
example,
and
it
gives
back
two
flags,
one
is
a
user
authorized
and
the
second
one
is
user
is
admin.
For
example,
we
can
check
that
the
right
part
of
the
response
data
was
passed
to
to
the
service.
A
So,
finally,
for
this
argument
we
have
a
tetroplet
of
the
origin,
pure
origin,
service,
ID,
origin
function
and
the
field
name,
and
all
of
this
is
checked
with
the
the
signatures.
All
the
data
or
the
response,
where
the
the
sphere
and
by
the
getter
that
was
executed
by
Aqua
VM.
So
this
is
what
you
can
rely
on
and
usually
it's
enough.
We
decided
not
to
make
it
recursive,
so
you
cannot
check
the
arguments
of.
A
But
if
you
need
arguments
you
just
pass
it
to
the
response
to
something
like
that.
So
it's
enough
and
a
service
can
add
any
logic
to
check
it.
A
Pure
selection,
no
decision
in
aqua
about
how
to
select
peers
but
aquarium
checks
that
the
data
was
a
collected
correctly.
So
we
have
some
proposed
solutions
for
Pure
selection
registry
and
Trust
graph.
Both
are
opt-in
and
Beyond.
The
scope
of
my
talk,
compute,
reactive
events
and
so
on.
How
exactly
we
do
compute?
Can
we
make
HTTP
hooks
for
aqua
and
do
something
like
that?
It's
a
topic
on
its
own
and
we
have
some
proposed
Solutions.
We
have
Marine
as
a
wasp
runtime
for
sandbox
at
execution
and
controlled
effects.
A
Hopefully,
Mike
will
tell
about
Marine
tomorrow
with
a
web
assembly
with
a
ipfs
and
for
HTTP
Hooks
and
reaction
on
events.
We
have
a
draft
project
named
Aqua
spells.
Is
some
security
considerations
inside
so
we'll
tell
nothing
about
that
right
now,
a
very
important
thing
when
I
redesign,
all
this
stuff
is
to
forbid
Aqua
calls
from
aqua
to
avoid
amplification
amplifications.
A
So
if
you
can
have
a
detached,
Aqua
call
triggered
by
Aqua
or
if
you
can
call
Aqua
from
the
service
which
is
called
by
Aqua,
it's
super
easy
to
create
an
infinite
untraceable
load
on
the
network,
so
by
any
means
we
are
trying
to
forbid
this
until
the
pier
is
super
crazy
and
allows
it
explicitly,
especially,
we
are
trying
to
avoided
and
we
have
a
concept
of
distributed
gas
probabilistic
distributed
gas
to
prevent
amplification
attacks
and.
A
Let's
thank
thanks
to
the
reasonability
of
here
of
this
very
strict
set
of
Pi
calculus
derived
instructions,
so
we
can
put
an
upper
bound
on
the
way
limit
of
network
hops
service
calls
and
all
other
effects
of
execution
and
use
some
heuristics
for
accounting
of
parallel
branch,
which
we
don't
know
what
what
exactly
happens
inside
and
also
we
have
to
limit
number
of
Cycles
for
every
four
instruction.
A
Otherwise
it
also
could
blow
up
so
it's
not
yet
implemented.
It's
drafted
planted
started
for
further
research.
Hope
to
make
a
different
talk
about
that.
A
Okay,
now
about
plants,
Aqua
is
unfinished
and
I
believe
that
nothing
is
finished
until
it
ends.
So
that's
fun
that
it's
unfinished
and
we
have
a
lot.
A
lot
of
things
not
decided,
not
resolved,
not
done
like
open
and
aqua
is
actually
made
a
very
inspired
by
lipid2p,
Design
and
approach.
When
you
have
small
pieces,
everything
is
composable,
you
can
change,
you
can
decide.
A
So.
First
of
all,
we
are
thinking
very
seriously
about
IPL
team,
because
it's
just
slightly
richer
than
our
implementation
of
webassembly
interface
types,
and
it
has
you,
know
syntax.
So
probably
we
will
implement
it.
Currently,
we
are
thinking
about
that.
A
Then
you
can
express
almost
everything
with
pi
calculus,
but
it's
nice
to
have
syntax
sugar
for
common
use
cases,
and
we
were
thinking
about
supervising
patterns
like
in
actor
model
or
something
like
that,
because
if
you
have
a
workflow,
sometimes
it's
quite
hard
to
understand,
was
it
successful
or
not,
and
how
exactly
to
show
was
it
successful
or
not?
So
we
are
thinking
about
eating
invariance
that
this
block
of
code
is
successful.
A
If
this
calls
it's
unsuccessful
is
if
this
calls
so
that
the
piping
patterns
were
like
Railway
railroad,
pattern
of
error
management
could
be
implemented
and
that's
about
raw
handling
and
the
piping
is
about
optimization
as
well
and
compatibility
of
the
flows,
because
currently
it's
one
flow
then
another,
and
they
don't
try
to
optimize
themselves
if
they
they
do
something
on
the
same
set
of
Piers,
for
example,
then
libraries
usage
is
not
very
handy.
Currently,
we
don't
have
asset
lip
aqua
with
the
default
algorithms
working
on
that
right
now
and
we
want
more
tooling.
A
We
have
some
tooling
currently
like
IDE
support
for
this
code,
with
the
go
to
definition,
syntax,
highlighting
and
something
else.
We
have
CLI,
we
have
another
CLI
and
so
on,
but
the
more
the
better
and
and
the
better,
the
better
as
well
and
finally,
right
now,
Aqua
101
check
hands
on
Aqua
by
Alexi,
something
in
depths
by
Mike
and
and
the
very
end
of
our
track,
open
discussion
about
aqua
clippy
to
pipfs
and
how
how
all
of
this
could
play
together
and
we
have
Aqua
book.
A
Well,
we
have
the
language,
the
compiler,
we
have
a
integration
with
the
JavaScript
like
that,
creates
these
things
and
these
things
we
have
import
exports.
We
have
a
older
stack
for
marine
I,
think
that
Alexi
will
show
it
why
to
describe
policy
going
so.