►
From YouTube: Developer Community Call #1 l Fluence Overview
Description
00:00 Introduction
00:45 What is Fluence
05:11 Essentials of Fluence architecture
06:40 Fluence Peer
08:23 Aqua Virtual Machine
10:25 Aqua Intermediary representation low-level internal representation of the code that gets interpreted on AquaVM
11:11 Aqua, snippet of Aqua code
11:49 Aqua compiler
14:12 Fluence peer implementation in typescript
16:34 Relaying in Aqua
17:13 Fluence peer implemented in Rust aka Fluence Node
19:04 Services can exchange files
20:17 Marine - ultimate WebAssembly runtime for backends
22:21 Distributed Event Loops — “scheduled scripts”
24:02 Summing up. Fluence Network has two kinds of peers: 1. peer implemented with Typescript or Javascript (can run from the web browser) and 2. peer implemented with Rust (more powerful)
25:43 Services support
27:43 Why do you need Aqua if you can use Typescript?
35:54 Reusable (sub)protocols & builtin services
37:36 Aqua DHT (Routing)
38:54 AquaIPFS: adds compute to IPFS, adds file management to Fluence Network
39:51 TrustGraph — prioritizing, labeling peers
41:15 Developer Experience: tools to work with
43:25 Community links
44:29 Plan for community calls
46:00 Q&A part
46:01 How do you protect from spam or malicious code sent to be executed to other peers?
49:34 What is actually AquaVM?
52:13 Who chooses the peers to execute the code on?
56:50 How Ethereum is integrated or used?
58:23 What additional literature I can read regarding the topic?
Resources & Links
AquaVM https://github.com/fluencelabs/aquavm
Aqua in Browser https://fluence.dev/browser
Fluence documentation https://doc.fluence.dev/docs/
Discord Support https://fluence.chat/
Telegram https://t.me/fluencedev
GitHub https://github.com/fluencelabs
Join Fluence Labs https://fluence.network/join.html
Community wiki & slides https://www.notion.so/fluencenetwork/Fluence-Developer-Community-Calls-2733beddb3ff4e4986c4fcc830fc796d
A
Right
so
I'm
your
guinea,
I'm
co-founder
of
fluence
great
to
meet
everyone
who
I
haven't
met
yet
so
we
have
here
several
members
of
lund's
team
of
flynn's
labs
team
dmitry
my
co-founder
who's,
a
cto.
He
will
be
doing
public
hard
work
presented
today.
Tom
trump
rachel's,
co-founder
of
lewins
and
all
the
great
guys
wins
team,
analytics
bernard
valeria,
see
like.
A
So,
anyway,
we'll
get
some
time
to
to
talk.
So
I
wanted
to
remind
quickly
that
what
we
do
with
fluency
is
a
is
a
peer-to-peer
application
platform
or
the
decentralized
cloud
or
the
particular
computing
protocol.
All
of
that
is
kind
of
synonyms.
It's
basically
the
the
development
stack
and
the
protocol
and
the
network
which
allows
you
to
create,
deploy
and
run,
create,
appear
applications,
and
we
have
like
very
specific
and
great
development
stack
that
allow
you
to
do
it.
B
A
Trying
to
make
fluence
compute
layer
for
the
web
3,
because
in
the
web
3
we
have
storage,
identity,
oracles
like
all
kinds
of
stuff
on
chain
compute
that
works
sometimes
great,
sometimes
not,
but
what
we
miss
is
really
like
off-chain,
complementary
layer
that
would
host
all
like
the
software.
You
know
middleware,
apis
and
so
on
so
forth.
That
cannot
go
to
unchained
just
economically
and
in
terms
of
just
that
does
make
sense
to
put
on
chain,
but
also
you
don't
want
to
have
it
off
chain
in
centralized
cloud.
A
So
fluence
is
something
that
replaces
centralized
clouds
and
centralized
backends
and
fluent
stack
is
very
compatible.
It's
compatible
with,
like
any
web
3
product
calls.
I
designed
the
way
that
you
can
plug
any
storage
and
entity
on
chain
data
and
so
on,
for
us
like
chain
applications
and
yeah.
So
and
it's
allow
you
it
allows
you
to
build
a
lot
of
cool
stuff.
A
We
have
like
some
projects
like
the
network
is
like
already.
Basically,
the
protocol
is
live,
you
can
try
it,
you
can
build
it.
The
development
stack
works
and
we
have
some
projects
already
built
on
us.
We
sponsor
hackathons,
mainly
in
the
like,
related
to
ipv5
ecosystem
and
the
theorem
ecosystem,
because
fluency
is
already
integrated
with
ipfs
and
ethereum.
So,
like
maybe
later,
we
can
share
some
details
on
on
the
bounties
that
now
live
and
there
will
be
very
cool.
Monetization
opportunities
like
the
like
the
network
is,
is
open
source.
A
It's
it's
a
peer-to-peer
network
open
source,
but
we're
gonna,
have
a
governance,
talk
and
we're
gonna
have
the
incentive
layer
for
the
nodes
to
perform
computations
and
we're
gonna
have
the
ability
for
developers
to
create
useful
components
for
the
network
to
earn
a
revenue
that
which
will
be
the
part
of
kind
of
cloud
revenue
of
the
nodes?
So
it's
basically
the
fluence
decentralized
quality.
A
C
D
D
D
These
spears
are
programmable
with
aqua.
So
this
is
the
entry
point
into
the
fluence
network,
the
peers
and
their
behavior.
We
have
different
kinds
of
peers.
Peers
could
be
publicly
accessible
or
not,
and
we
have
two
implementations
of
fluence
peers
which
have
a
lot
of
things
and
behaviors
in
common
and
some
different.
D
D
D
D
D
D
D
Particle
consists
of
some
code
in
the
form
of
here.
I
will
tell
about
it
later
and
data
that
holds
the
results
of
previous
execution.
So
every
time
the
data
comes
into
the
air
interpreter
into
aqua
vm,
it
verifies
previous
executions,
including
signatures
data,
and
so
on
that
the
riot
peers
did
the
right
job.
D
D
D
D
D
For
people
we
have
aqua
aqua
is
a
high
level
programming
language
for
distributed
systems
and
peer-to-peer
it's
a
kind
of
a
dsl
that
lives
on
its
own.
It
has
a
some
compiler
and
it's
designed
to
describe
distributed
flows,
peer-to-peer
flows.
So
that's
a
snippet
of
what
aqua
could
look
like
here.
We
have
the
fanout
event,
that's
the
code
snippet
from
one
of
the
users
of
the
language
and
finally,
it's
compiled
to
error.
D
D
That's
a
pretty
new
approach,
as
you
can,
for
example,
make
an
a
publisher,
subscriber
or
many
implementations
of
published
subscriber
protocols
and
run
them
in
parallel
on
the
same
notes
without
need
to
redeploy
them
or
you
can
implement
cademlia
or
you
can
implement
raft
in
aqua
and
then
add
more
and
more
behaviors.
Indeed,
the
compiler
targets,
mainly
typescript
and
javascript,
and
the
compiler
itself
is
compiled
to
javascript
and
npm,
is
the
default
distribution
mechanism
for
the
compiler
and
for
the
aqua
code.
D
D
D
D
So
what
is
special
in
the
fluency
implementation
in
typescript?
First
of
all,
is
the
main
compilation
target
for
aqua,
so
the
usual
flow
for
developing
for
fluence
is
to
write
some
aquacode
then
compile
it
with
a
compiler
with
a
with
a
cli
and
then
call
it
as
a
typescript
or
a
javascript
function.
Here's
the
example:
get
price
is
an
implementation
of
of
an
oracle
on
influence
and
it's
just
provided
as
a
an
asynchronous
function
for
typescript.
D
D
D
D
D
D
D
D
It's
like
a
chrome
like
air
means
aqua
scripts.
We
call
it
scheduled
scripts,
so
you
can
take
an
aqua
function,
compile
it
and
upload
as
a
script,
to
influence
node
and
to
specify
an
execution
schedule
like
every
one
minute,
for
example,
and
it
means
that
you
can
wake
up
your
services
periodically
and
do
something
with
it.
For
example,
it's
very
useful
to
perform
data
replication
or
synchronization
with
these
schedule.
Scripts.
D
E
D
D
D
Yep
you
can
and
like
aqua,
the
language
is
quite
affordable
and
it's
simple.
It's
simple
because
it's
not
turing
complete
by
the
way-
and
it's
very
domain
specific,
so
it's
quite
straightforward
to
use
it
for
typescript
developers
without
touching
rust.
But
if
just
connecting
the
browsers
is
not
enough,
we
have
some
defaults
provided
as
services
eddie.
F
F
D
D
You
don't
notice
the
difference
between
the
peer
implementations
and
actually
this
three
layers
system.
Design
of
the
fluence
bureau
is
more
or
less
straightforward
to
implement
in
other
languages,
because
we
have
mainly
p2p
implementations.
We
have
web
assembly
support
in
many
environments
and
the
services
support
could
be
different
and
the
most
you
you
can
attach
the
most
suitable
one
for
your
favorite
language.
E
D
D
We
study
this
in
in
aqua
in
in
the
intermediary
intermediary
representation
in
error.
So
we
have
very,
very
simple
instructions
here,
like
sequential
execution,
do
the
first
one
and
then
the
second
and
then
we
realize
that
it's
hard
to
work
with
and
we
decided
to
make
a
dsl
that
follows
all
the
constraints
and
limitations
and
possibilities
and
capabilities
and
contracts
of
this
low-level
work
like
rocket
science
kind
of
stuff
in
in
an
affordable
way.
Affordable.
What
do
I
mean?
I
mean
that
we
could
have
made
and
we
tried.
D
D
D
If
you
try
to
compile
arbitrary
code
to
this
kind
of
asynchronous
flow,
you
need
to
split
it
in
there
with
a
asynchronous
boundaries,
and
it
means
that
you
need
to
have
some
specific
semantics.
For
example,
here
we
have
on
semantic.
You
need
to
explain
where
exactly
you
want
to
go
after
the
asynchronous
boundary,
but
rust
doesn't
help
with
it.
It
helps
with
the
lifetimes,
with
the
different
data
types
and
so
on,
but
not
with
distributed
flows.
D
But,
finally,
if
anyone
wants
to
implement,
I
don't
know
rust,
library
or
typescript
or
anything
else
that
can
can
be
divided,
that
will
compile
the
code
into
computations
in
terms
of
services
or
functions
or
don't
know
what
and
workflow
orchestration
in
in
terms
of
by
calculus
just
go
ahead.
I
think
it's.
It
is
good
and
it's
absolutely
possible.
E
Yeah
thanks
for
awesome
answer,
let
me
add
a
little
bit
to
it
so
in
shirt
you
can
use
typescript
to
define
your
logic
on
a
single
peer,
but
for
anything
that
involves
peer-to-peer
network
interaction,
you
will
better
use
aqua
because
it
provides
different
primitives
for
routing
and
forwarding
messages
and
also,
as
dmitri
said,
aqua
provides
different
security
guarantees
because
it's
not
tier
incomplete
and
because
it's
domain
specific
and
it
tracks
the
signatures
of
calls
and
stuff
like
that.
So
for
anything,
that
involves
peer-to-peer
interaction.
E
Aqua
is
the
best.
So
it's
like
a
kind
of
orchestration
language
which
you
can
use
to
like
compose
different
services.
Different
peers
take
execute
different
functions
on
this
peers
gather
the
data
then
forward
it
to
some
other
place,
maybe
send
different
events
to
your
users
or
compute,
like
a
mean
average
of
different
prices
from
different
oracles
and
compose
all
that
to
a
single
value
and
send
back
to
your
user
to
your
application
stuff
like
that.
D
E
D
D
D
D
D
So,
for
example,
you
can
do
publishers,
publisher,
subscriber
using
this
or
you
can
do
broadcasts
or
you
can
do
chat
room
or
you
can
do
just
a
multi-client
setup
when
you
have
multiple
devices
and
want
to
receive
notifications
to
all.
But
initially
it
starts
with
creating
your
own
key
on
the
aqua
ht,
and
then
you
or
maybe
other
peers
may
add
records
that
points
to
actual
runnable
code,
which
includes
peer
id
service
id
and
relay
id
service
id
and
the
relay
id
are
optional.
D
D
So
we
have
a
lot
of
tools
and
means
to
work
with
with
fluence
network
and
to
make
peer-to-peer
applications
fast
and
like
to
debug
them
and
so
on.
The
main
parts
are
aqua
and
marine
with
aqua.
You
can
compile
run
and
provision
aquascripts,
and
it's
also
used
to
deploy
the
services
and
the
main
purpose
is
to
program
distributed
networks.
D
D
D
I
we
have
a
telegram
chat
for
developers,
influence
underscore
dev.
All
the
code
is
open
source
in
the
fluence
labs
github
organization.
We
are
hiring
some
like
you.
You
can
take
a
look
on
our
offerings
on
fluence.network,
slash,
join
html,
we
sponsor
hackathons,
currently
is
bitcoin
and
it's
online
and
on
the
following
community
calls.
We
will
invite
some
projects
or
maybe
even
you,
to
present
what
you're
building
on
flints.
What's
your
experience
and
so
on,
so
we
want
to
grow
the
community
with
the
with
your
help.
D
We
have
a
plan
for
community
goals,
so
today
it
was
just
an
overview
of
what
exists
and
that's
all
and
on
the
following
community
calls
on
the
following
events:
we'll
focus
on
different
technologies,
we'll
start
with
aqua
continue
with
marine.
Then
we
will
go
in
depth
into
aqua
virtual
machine
and
this
by
calculus
crdt
implementations.
E
D
D
D
Yeah
we
will,
we
will
have
it,
but
actually,
I
think
that
we
will
at
first
we
will
cover
parts
of
this
problem,
like
part
by
part,
for
example,
in
the
marine.
When
we
will
speak
about
marine,
we
will
speak
about
isolation,
memory,
isolation,
yz
interfaces
and
so
on,
and
the
particle
file
bolt
and
like
something
like
that,
how
we
we
make
it
impossible
to
exit
to
to
escape
the
sandbox
when
we
will
speak
about
awkward
vm
well,
like
we'll
cover
it
step
by
step.
E
G
Yes,
hi
guys,
sorry,
I'm
without
camera
today,
so
regarding
this
question,
aqua,
vm
and
services
are
two
different
things
and
aqua
vm
could
call
services
and
services
now
could
be
located
only
on
nodes,
not
on
clients.
By
clients
I
mean
browser,
but
aqua
vm
could
be
run
both
on
nodes
and
browser
and
in
future
probably
we
could
also
allow
services
to
run
also
on
coins
and
like,
regarding
the
second
part
of
the
question
in
the
communication
with
browser.
G
Yes,
exactly
so
aquarium
is
a
is
a
code
that
written
on
rust.
So
actually
it's
about
15,
000
lines
of
code,
it's
written,
rust
and
then
and
compiled
to
webassembly
and
run
both
on
client
and
on
on
node
and
like
on
a
client
it's
run
as
with
help
of
wasm
by
engine.
So
it's
just
yes
web
assembly
module
that
runs
through
some,
like
general
browser,
virtual
machines
like
v8
for
chrome
and
the
spider
monkey
for
firefox
and
so
on,
and
on
note.
It's
runs
through
our
runtime.
That
dimitri
said
that
called
marine.
E
Okay,
thank
you
mike.
So
the
next
question
I
think
I'm
going
to
take
it,
who
choose
the
peers
to
execute
the
code.
All
so
you
aqua
gives
you
ability
to
lay
out
the
routing
that
you
want
to
have.
You
have
to
find
peers
on
your
own
like
currently,
we
have
devnet
and
desnet,
and
you
can
use
any
peer
for
rooting
there.
Everyone
every
peer
will
just
serve
you
as
you
ask
there
is
no
like
there
are
no
rules.
E
You
just
do
what
you
want,
so
you
just
write
in
aqua,
go
to
this
period
and
do
this
period
execute
this
service
on
that
period,
execute
this
service
and
that
pure
and
it
just
works
in
the
future.
It
will
be
a
little
bit
more
complex.
We
will,
you
will
have
to
find
relays,
you
will
have
to
add
them
to
truss
graph
and
stuff
like
that,
but
currently
you
just
specify
the
routing
the
sub
networks,
the
travel
path
for
particles
that
you
want
and
that's
it.
It
just
works.
D
Finally,
the
code
is
executed
somewhere
on
on
certain
peers,
so
between
you
and
the
code
execution
somewhere.
There
is
a
the
process
that
we
call
routing
and
it
means
that
you
map
the
job
that
you
have
to
some
peers
which
are
capable
to
to
handle
this
job
so
in
in
aqua.
You
don't
have
to
specify
all
the
ids
of
all
the
peers
in
advance.
D
D
E
Yeah,
and
one
more
thing
to
add
is
that,
while
you
want
to
call
services,
if
you
want
to
call
some
code
to
execute,
it
should
be
a
flynn
service,
but
the
it
could
be
just
an
adapter
to
an
external
service,
you
can
integrate
with
ethereum
node
or
you
can
integrate
with
some
external
service.
You
can,
for
example,
host
make
some
hoster
hosts
some
application
that
he
cared
about
some
demon.
For
example,
ipfs.
E
H
Sure
it's
the
integration
is
basically
it's
ad
hoc
right
now,
but
we
got
a
pattern
for
it
and
supporting
some
of
the
web.
3
libraries
is
is
on
our
list,
so
we've
done
it
through
json
rpc
right
now,
because
one
of
the
really
cool
things
with
the
particular.
So
if
you
go
through
the
rest,
you
can
use
curl
to
do
your
json
rpc
calls.
H
If
you
use
the
client
based
approach
with
javascript,
you
can
just
import
one
of
the
web
3
libraries,
but
from
a
purely
distributed
perspective
there
is
no
library
available
right
now.
However,
however,
we
have
two
hackathons
going
on
right
now
that
actually
rewards
you
of
working
on
this
very
particular
topic.
We
get
the
git
coin,
gr11
hackathon
going
on
right
now
and
we
have
the
east
global
hackathon
starting
this
week.