►
From YouTube: Fluence Workshop: developing services + Intro to Fluence
Description
00:00 Intro
01:31 Workshop prerequisites
02:26 What is Fluence
04:43 Fluence use cases
05:42 Aquamarine programming language
07:25 Services in Fluence
10:44 AIR, Aquamarine Intermediary Representation
11:33 What you can build with Fluence
11:56 Examples of Fluence applications
12:36 Bounties for Hack The System hackathon overview
15:37 The purpose of the workshop
16:52 Setting up environment
18:15 Setting up Fluence tools
23:33 Examples of the apps built with Fluence
25:03 Run local Fluence node
27:28 Check the local node work
32:20 Working with services using AIR. Deploy a service
41:02 Call service API
46:20 Compose services
52:10 Useful resources
To follow this workshop: https://www.notion.so/Fluence-workshop-developing-services-b1bfbf9f76d94135b56394e83fc0a8e9
Previous workshop: https://medium.com/encode-club/hack-the-system-fluence-workshop-1-video-documentation-d0a2052e8f7e
Fluence challenges https://medium.com/encode-club/hack-the-system-announcing-fluence-87fa8dae59?source=friends_link&sk=18b7d34bdf4436d4193f69090aae9157
Get started with Fluence https://fluence.dev/docs
Protocol Paper https://github.com/fluencelabs/rfcs/blob/main/0-overview.md
Developer Hub https://dash.fluence.dev/
Github https://github.com/fluencelabs
Youtube channel https://www.youtube.com/channel/UC3b5eFyKRFlEMwSJ1BTjpbw
Fluence Home https://fluence.network/
Original video: https://www.youtube.com/watch?v=MgdVahMsvpQ&feature=emb_imp_woyt
A
So
welcome
everyone
to
the
fluent
second
workshop
of
the
hackler
system.
Hackathon.
Thank
you
all
for
joining
tonight,
and
hopefully
we
have
some
people
from
the
previous
workshop
as
well.
But
if
not,
I
believe
afghani
is
gonna,
be
giving
a
kind
of
introduction
to
fluence
presentation
quickly
before
we
head
into
the
more
technical
stuff
later
on
in
the
in
the
event.
A
So
do
we
have,
I
see
we
have
alexi
and
anna,
and
do
we
have
evgeny
here
as
well,
if
so
just
pop
your
screens
on.
So
we
know
you're
here,
but
in
terms
of
the
the
hackathon
in
general,
we're
now
in
in
week
four
of
the
hackathon,
which
is
coming
towards
the
end
of
the
education
piece,
and
so,
if
you
haven't
yet
started
building
your
project
I'll
begin
to
start
thinking
about
that
this
week.
A
And
next,
as
we
have
the
final
few
workshops
perfect,
we
have
jeff
getting
here
and
in
terms
of
upcoming
events.
After
the
fluence
workshop
today,
we
have
the
one
with
polygon
next
week,
who
used
to
be
called
matic
and
after
that
we
have
stella's
second
workshop
and
finally,
the
coin
market,
cap
and
sandbox
game
of
all
workshops,
as
well,
so
without
further
ado
I'll
hand
over
to
the
co-founder
of
fluence
evgeny.
Thank
you
very
much
for
joining
us
this
evening.
B
Hello,
hey
everyone.
Thank
you
for
coming.
Thank
you
for
giving
me
this.
This
introduction
talk
so
I'll.
Oh
sorry,
I
will
try
to
just
briefly
explain
what
fluency
is
and
why
we
are
doing
this
and
why
it's
so
cool
before
alexi
follow.
You
follows
you,
through
the
workshop,
just
a
reminder
for
anyone
who
missed
our
first
workshop.
B
So,
first
of
all,
for
this
workshop
just
check,
you
will
need
npm
or
yarn
installed.
You
know
docker
and
git,
and
I
believe
there
is
a
link
to
the
notion
page
with
the
workshop
detail
right
now
in
the
chat,
so
feel
free
to
go
there
and
while
I'm
talking
just
check
out,
what's
gonna
be
happening
after
and
also
there
will
be
rust
and
web
assembly
needed,
but
alexa
will
explain
how
to
install
it
properly,
if
you
don't
have
it
in
the
system,
yet,
okay.
B
So
what
is
what
is
fluence
at
fluence?
We
are.
We
are
building
the
decentralized
analogy
to
clouds.
Basically,
so
we
create
the
pure
development
stack
that
allows
you
to
create
any
kinds
of
applications
or
backhands
with
avoiding
proprietary
cloud
tooling
or
centralized
servers
or
centralized
cloud.
B
So,
when
you're
developing
your
application,
you
fully
rely
on
open
source
tools
and
open
source
tag
that
fluence
provides,
and
using
this
stack,
you
can
create
all
kinds
of
from
end
to
end
peer-to-peer
applications
to
traditional
distributed
systems
and
deployed
back
to
the
cloud,
but
not
being
really
dependent
on
their
managed
services
or
their
proprietary
sdks,
and
so
on.
Also
using
fluent
stack,
you
can
compose
different
apis
services
data
sources
and
I
will
also
without
reliance
on
something
proprietary.
B
I
will
show
you
some
examples
of
it
and
soon
when
we
have
the
blockchain
layer,
you
will
be
able
to
monetize
some
stuff
that
you
created
that
other
people
using
in
the
network,
so
they're
gonna,
be
the
common
network
they're
going
to
be
the
blockchain
they're
going
to
be
payments,
so
some
people
will
be
able
to
host
services
for
other
people,
so
it
all
will
start
working
as
a
decentralized
hosting
network
and
right
now,
because
there
is
no
blockchain.
Yet
there
is
no
incentivization
or
ability
to
pay
other
people
to
host
services.
B
You
can
create
applications,
but
you
will
be
able
to
you
will
you
will
make
sure
that
you
are
hosting
back-end
services
by
yourself
or
you
know
exactly
who
costs
your
back-end
services?
So
you
cannot
just
rely
on
the
network
to
provide
you
some
guarantees
about
availability
of
services
that
you
created
and,
if
you,
if
you
think
of
like
what
you're
trying
to
achieve
here,
similarly
to
how
defy
enabled
composability
for
financial
tools
and
components,
we
are
trying
to
create
the
common
medium
of
composability
of
back-end
stuff.
B
B
Similarly,
how
you
usually
use
amazon
lambda,
for
example,
when
you're
composing
different
microservices
in
the
cloud
so
you're
saying
I
want
this
user
request
to
go
to
this
service
and
then
execute
this
function
and
then
go
back
to
me
and
then
go
to
the
second
service
and
execute
second
function.
And
then
you
know,
put
some
data
to
database.
B
Similarly,
aquamarine
allows
you
to
do
that,
but
without
any
centralized
place
where
all
these
scripts
are
executed.
Scripts
are
being
attached
to
data
packets
and
they
go
to
the
network
and
being
executed
by
the
network
step
by
step,
and
it
allows
you
to
create
everything
from
simple
request
response
to
complex
networking.
Algorithms,
like
dft
consensus
raft,
gaussian
protocols
like
any
kinds
of
networking
protocols
can
be
can
be
programmed
using
aquamarine
and
the
second
thing
is
services.
Fluence
has
services
similarly
to
microservices,
but
services
in
the
fluence.
B
They
are
web
assembly
based,
so
they
have
all
benefits
from
webassembly
sandbox.
They
are
like
they're
fast
and
their
size,
not
a
huge,
sound.
The
docker
like
another,
huge
docker
containers,
it's
like
a
really
small
web
assembly
by
services.
They
are
composable
over
the
network,
viacom
marine
that
can
they
can
be.
They
can
contain
some
state.
They
can
be
fully
stateless,
so
it
can
be
just
some
function
that
calculates
you
something
that
lives
somewhere
in
the
network
on
some
node
and
they
are
extendable
with
external
data.
So
you
can.
B
When
you
create
a
service,
you
can
connect
it
to
external
data
sources,
to
apis
or
to
decentralized
storage.
For
example.
You
want
to
you
create
in
the
chat
application
that
saves
that
sends
messages
between
browsers
but
also
saves
the
messages
history
into
the
decentralized
storage.
So
you
can
create
a
plugin
to
ipfs
or
skynet
or
rv
for
anything
else
and
use
fluent
stack,
connect
it
with
this
external
storage
and
store
the
data
there.
B
So
the
data
availability
will
be
provided
by
this
protocol
and
the
your
application
logic
will
be
executed
by
fluence
network
and
this
obviously
works
for
blockchain
data.
So
you
can
connect
to
blockchain,
for
example,
to
ethereum.
You
can
read
data
from
ethereum
and
you
can
do
something
whatever
you
need
in
your
application,
with
blockchain
data
and
so
akumari
aquamarine
is,
is
intended
to
be
the
high-level
programming
language
that
you
can
see
on
the
right,
but
it's
not
ready
yet.
B
So
we
have
the
intermediary
representation
of
aquamarine
that
we
call
air
and
it
looks
like
a
lisp
style
language
on
the
left,
but
it's
not
so
hard.
So
if
you
are
not,
if
you're
not
creating
huge
and
super
complex
algorithms,
it's
it's
pretty
easy
to
program.
Your
scripts
and
alexa
will
show
you
a
couple
of
examples.
During
the
workshop,
also
a
few
things
so
like
currently,
what
you
can
do
is
this
here.
B
Yep,
sorry
guys,
so
what
you
can
do
is
air.
Today
you
can
connect
peers.
You
can
discover
peers,
you
can
call
functions
on
the
peers,
you
can
deploy
services
to
different
nodes
and
you
can
do
all
kinds
of
networking
stuff.
So
you
can
set
up
loops
of
requests.
You
can
execute
them
in
parallel.
You
can
handle
error
and
gets
get
error
back
to
the
pure.
That
started
the
execution
of
your
script
and
you
can
have
authorization.
B
You
can
have
custom
authorization
for
your
application
to
allow
some
some
peers
to
write
in
you
into
your
services
and
some
some
people
not,
and
so
you
can
find
all
this
in
in
the
documentation
and
finally,
what
you
can,
what
you
can
build
with
fluence
and
I'll.
Give
you
a
couple
of
examples,
so
you
can,
you
can
think
of
any
anything
like
from
end-to-end
people.
B
Applications
like
chats
collaborations,
like
online
collaboration,
real-time
collaboration,
gaming
stuff
that
works
without
backhand,
and
just
use
this
network
to
relay
messages
to
connect
your
browser,
peers
and
relay
messages
between
them.
You
can,
for
example,
create
something
very
different
which
is
like
a
blockchain
like
the
oracle
system
for
blockchain.
B
You
can
use
fluent
stack
to
create
oracles
and
to
deploy
them
to
some
nodes
and
to
read
they
subscribe
to
data
from
the
chain,
and
so
like
use
all
this
student
to
to
create
oracle
system,
you
can
potentially
create
the
applications
that
are
governed
and
run
by
community,
and
what
does
it
mean?
It
means
that
currently,
when
the
application
has
a
backhand
and
backhand
sleeve
in
the
cloud,
someone
should
have
the
admin.
You
know
credentials
of
this
cloud.
B
So
they're,
always
the
person
that
can
switch
off
the
back
end
of
the
application
and
our
hosting
marketplace
basically
allows
you
to
and
like
in
the
in.
The
stack
itself
allows
you
to
build
application.
The
way
that
backend
services
can
be
run
by
many
community
members,
and
if
you
design
your
application
properly,
then,
basically,
any
any
user
can
open
the
front
end
of
your
application,
which
will
call
one
of
backend
services
being
being
hosted
by
one
of
community
members,
and
then
it
would
work.
B
So
if
one
of
the
conservancies
will
go
down,
there
are
others
that
that
can
be
used
to
serve
the
business
logic,
and
it's
all
can
be
connected
to
dao's
chain,
for
example,
if
you
want
so
it
can
really
go
much
more
comprehensive
and
you
can
create
any
kind
of
network
algorithms,
some
distributed
system
stuff.
If
you
want
to
play
with
air,
you
can
think
of
any
kind
of
consensus
systems
or
messenger
protocols,
and
so
a
couple
of
examples.
We
have
the
example
of
code
collaboration,
application
that
uses.
B
We
have
three
bounties
for
this
hackathon.
First,
two
really
really
simple
and
everyone
who
builds
them
can
can
get
the
bounty.
So
if
you
use
air
in
your
application,
you
get
the
first.
If
you
use
air
and
deploy
air
a
service
to
the
network,
you
get
the
second
and
best
applications
get
top
boundaries,
and
you
can
see
more
details.
If
you
follow
this
about
the
bounties
and
that's
it
from
from
me.
C
C
Today,
I'm
gonna
focus
on
how
to
develop
services
locally,
how
to
run
your
own
node
to
connect
to
the
network.
So
you
can
see
the
logs.
You
can
see
the
output,
you
could
be
missing
from
the
other
tools,
other
means
and
that's
basically
it
it's
going
to
be
pretty
sure,
but
I
I
hope
you
will
enjoy
and
again
for
more
detailed
explanation
on
how
to
develop
services.
You
can
refer
to
the
previous
workshop
it's
available
down
here
below
in
the
links.
C
Thus
I
would
not
cover
what
I
will
cover
is
setting
up
the
rust
and
cargo
and
stuff
and
then
setting
up
fluence
tools.
So,
let's
start
with
setting
up
the
rust,
it's
pretty
easy.
You
just
have
to
copy
this
command
and
paste
into
your
terminal,
and
then
it
will
ask
you
and
you
will
just
press
one
and
it
will
do
in
a
few
minutes
that
will
work
and
that
will
install
you
rust,
nitric
tool
chain.
C
If
you've
ability
to
compile
rust
to
web
assembly
right
away
so
yeah
after
installation
is
done,
you
would
need
to
either
reopen
your
terminal
or
or
execute
defaulting
command
in
your
terminal,
and
you
can
check
then
that
the
cargo
is
available
by
well
executing
cargo
minus
minus
version,
so
I
hope
you're
starting
doing
that.
In
the
background
and
in
another
tab
we
can
begin
set
down
the
fluency
tools.
C
First,
one
is
flgs:
it's
a
tool
to
interact
with
the
flint's
network,
to
deploy
services,
to
inspect
them
to
execute
air
scripts,
and
this
is
your
go-to
cli
tool
to
work
with
the
fluence
network
that
you
should
use
to
manage
your
services
and
inspect
them
and
stuff.
So
installation
is
pretty
simple.
You
just
need
to
call
npm
install
install
globally
on
this
package.
So
you
just
the
same.
C
C
Let
me
make
it
bigger:
it's
really
a
lot
of
them
here,
so
you
can
do
a
lot
of
things
with
the
network.
You
can
upload
modules,
you
can
inspect
modules
on
the
net
on
the
nodes
of
the
network.
You
can
get
interfaces
of
your
services,
you
can
create
services
and
that's
basically
it
and
you
can
of
course,
execute
scripts
vivaldi's.
C
C
This
is
you
will
need
for
this
current
workshop,
but
overall,
it's
a
useful
tool,
so
you
can
develop
your
services
locally
without
deploying
them
anywhere
it's
as
easy.
As
a
previous
one.
You
just
copy
paste
it
in
your
terminal
and
it
it
installs.
You
can
check
them
that
it's
installed
by
printing
fc
version
and
it
should
be
fine.
You
can
know
that
fk
and
fc
are
different.
C
That's
how
it
works
so
mind
that,
and
the
final
step
we
need
to
do
is
to
copy
the
examples
repository
you
can
do
it
like.
You
usually
do
copy
the
git
repositories,
it's
pretty
simple,
so
you
copy
whoops
either
this
line,
if
you're
after
authorized
in
github
through
https
or
this
one,
if
you're
using
ssh
keys
for
authorization.
B
You
know
like
a
fundamental
guarantees
that
this
node
will
will
continue
to
serve
your
services
until
you
do
it
yourself,
at
least
at
one
node,
and
this
is
why
I
I
talked
about
example
of
community
run
applications,
so
you
have
a
community.
You
have
a
several
people
who
committed
to
the
hosters
of
of
your
application.
Backhand.
B
C
C
C
C
C
To
we
can
just
paste
this
here,
we
can
also
pass
arguments
here,
so
we
can
see
what
the
possible
options
for
this.
Let
me
just
update.
If
you
ever
find
yourself,
if
you
you
have
used
the
flint's
node
before
you
can
always
update
it
by
using
docker
pool,
that's
a
good
thing
to
do,
because
we
deliver
releases
pretty
often
and
it
changes
pretty
often
so
if
anything
doesn't
work
for
some
reason.
You
always
start
with
dr
paul
first
or
ask
question
right
away
in
the
discord.
C
C
Few
interesting
thing
you
can
see
here
also
is
the
peer
id
of
the
node
that
we
just
started.
You
will
need
it
to
deploy
services
and
to
manage
them
and
to
call
them.
So
it's
a
really
important
information.
You
can
see
here
the
version
of
the
air
interpreter.
That's
a
webassembly
module
too.
So
everything
is
portable
and
the
very
same
air
interpreter
is
running
in
the
browser
when
you're
using
print.jssdk.
C
C
A
C
C
So
we
just
select
this
paste
into
the
terminal,
and
then
we
select
this
so
the
what
we
just
done.
We,
I
have
created
a
file
script
layer.
It
contains
the
script
of
two
lines:
go
to
the
relay:
save
hello
as
a
variable
under
name
result
and
then
send
these
result
to
the
client
to
the
init
peer
id.
So
it's
the
this
is
the
id
of
the
initiator
of
the
script.
C
C
We
will
need
to
specify
by
a
path
to
the
script
and
address
of
the
node
by
default.
It
it
address
of
the
node
in
the
network,
but
here
we
want
to
use
address
of
the
node
of
our
local
node.
That's
why
we
specify
here
our
localhost,
and
here
we
specify
localhost.
Then
we
specify
a
port.
We
say
that
you
should
expect
websocket
on
the
port
for
nines,
and
this
way
we
specify
the
pure
id
of
the
node,
so
it
works
as
a
public
key.
C
C
C
C
So
here
we
have
our
result.
You
can
see
that
it's
wrapped
in
array
like
just
like
here,
okay,
and
also,
we
can
see
that.
Let
me
repeat
that
again,
so
we
can
see
the
logs.
So
here
we
can
see
the
node
that
the
node
received
this
particle
and
executed
the
script.
You
can
see
that
we
have
executed
the
op
identity
operation.
It
basically
means
return.
Identity
is
a
mathematical
operation
of
returning
back
what
it
received.
So
if
you
call
identity
one,
you
receive
one
back.
C
C
C
C
If
you
wish
to
learn
how
to
connect
front-end
to
the
back-end,
you
can
refer
to
the
previous
version,
okay,
so
the
interesting.
So
what
will
happen
now?
We
need
to
deploy
the
service
how
that
works?
Let's
see,
let's
here
we
have
a
deploy.sh
script.
That
does
all
the
work,
but
if
we
don't
know
what's
inside,
that's
not
interesting
right.
We
need
to
know
how
it
works
to
understand
how
the
deployment
process
works.
Interference
network,
so
what's
happened,
what's
happening
here.
C
C
C
C
C
C
C
C
A
C
C
It
will
return
the
results
and
that's
exactly
what's
happening
here
in
the
rust
code,
except
that
it
it's
in
a
sandbox
and
the
only
way
to
get
access
to
the
curl
command
is
to
explicitly
give
permission
to
call
the
curl
binary
here
under
the
name
curl.
So
what
this
thing
in
the
config
does
this
section?
It
allows
service
to
call
the
curl
binary.
C
C
C
C
A
C
C
C
C
C
C
C
C
C
C
C
A
C
C
You
can
return
your
own
structure.
Any
structure
that
you
want,
except
enums,
can
be
returned
from
the
function
and
you
can
manipulate
it
directly
in
the
script.
I
will
show
you
how
in
a
moment,
so
here
you
can
see
that
we
have
exactly
what
has
been
returned
by
the
curl,
but
as
a
string
here
in
spd
out.
So
you
can
tell
that
it's
as
simple
as
working
with
binaries
and
it
allows
you
to
access
external
network
resources
easily.
C
C
C
So
basically,
we
just
executed
a
curl
binary
that
queried
the
following
url
and
returned
its
result.
It's
a
simple,
really
really
simple
example,
but
since
it's
a
general
purpose
platform
that
where
you
can
program
and
express
any
logic,
you
want,
you
can
build
any
service
in
rust
and
you
can
build.
B
C
C
Just
to
show
you
a
simple
example
of
composing
services:
let's
well
compose
the
single
service
by
calling
it
twice
so
we'll
we'll
do
the
same
thing
as
before,
except
the
script.
Now
is
a
little
bit
more
complex.
We
have
a
nested
seek
instruction.
That
means
that
we
start
sequential
execution.
Then
we
start
another
sequential
execution
that
takes
only
two
instructions
and
we
execute
everything
one
instruction
after
another.
C
Here
we
we
have
a
language
reference
in
the
documentation.
Documentation
is
linked
in
the
resources
section
below.
I
will
show
it
to
you,
so
what
we
have
we
have
here
a
call
to
the
duckduckgo
about
the
same
condensed
milk,
and
we
have
a
call
to
doctor
go
about
definition
of
beetroot
and
here,
as
you
remember,
we
have
not
just
a
string
as
a
result,
but
but
a
structure
that
contains
std
out
field,
sdr
and
else
and
other
field
other
fields.
C
So
here
we
can
manipulate
the
data
fields.
We
can
access
them
directly
in
the
script,
so
this
makes
it
possible
to
have
your
data
manipulated
and
changed
without
any
central
authority,
since
this
script
is
attached
to
the
packet
and
sent
along
along
the
particles
and
executed
by
every
node,
it
mean
it
meets.
You
can
have
this
logic
executed
on
the
network,
not
on
some
central
authority.
C
A
C
Have
a
lot
of
output,
but
the
essence
is
the
same:
we
have
our
script
executed
and
we
have
two
calls
there
to
our
service
on
the
node
and
we
have
returned
two
results
this
time.
Let
me
zoom
out
so
it's
easily
seen
that
we
have
two
abstracts
here:
first
about
condensed
milk
and
second
about
beetroot,
and
here
you
can
see
that
all
that
this
data
was
produced
by
std
out
fields.
C
C
So
we
have
a
composition
here,
it's
a
single
service,
but
it
can
be
different
service.
It
can
be
tens
of
services.
You
can
compose
different
ethereum
oracles
and
calculate
prices
between
them
and
take
the
one
you
trust
the
most
and
send
it
to
your
application.
For
example,
you
can
really
do
anything,
you
can
imagine,
that's
it.
It's
a
short
one
this
time.
So
let
me
just
review
resources.
C
C
They
will
appear
in
this
list
of
services,
and
here,
if
you
run
your
node
without
the
minus
minus
local
at
the
end,
and
you
have
external
access
to
your
ip
address,
your
node
will
appear
here
too,
we
have
a
documentation
that
the
documents
how
to
use
air-
we
didn't
go
much
detail
this
time
about
it.
But
here
you
can
read
about
all
the
instructions,
all
the
possibilities,
for
example,
how
to
handle
errors
when
they
happen
and
how
to
iterate
through
the
arrays
in
your
scripts.
C
C
A
A
So,
if
you'd
like
to
go
and
look
at
that,
and
perhaps
follow
that
along
and
feel
free
to
follow
that
in
terms
of
the
encode
club,
discord
I'll
send
a
link
to
that
in
chat
now
as
well,
and
if
someone
from
the
fluence
team
would
like
to
put
the
influence
discord
as
well.
I'm
sure
they'll
be
more
than
welcome
to
take
any
questions
there,
also
and
in
terms
of
hack,
the
system
upcoming
events
wise.