►
From YouTube: Fluence – A Peer-to-Peer Computing Network
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
We
see
a
lot
of
you
know:
projects
semi-successful
around
identity,
and
you
know,
and
I
just
wanted
to
talk
specifically
about
what
happens
around
Computing
and
how
we
see
like
the
future
of
decentralized
computing.
So,
basically,
I.
Think
of
computing,
like
a
blockchain,
is
a
big
part
of
this
industry
because
that's
the
new
way
of
doing
computations,
it's
a
like,
very
expensive,
very
constrained
way
of
doing
computations,
but
they
were
created
for
a
specific
purpose
of
you
know:
Reinventing
money
and
like
financial
instruments.
A
And
you
know
the
point
that
that's
a
that's
a
long
concern
for
people
who
ever
built
anything
in
web
2
that
you
usually
wanna
build
the
the
you
want
to
create
some
new
applications,
some
new
business
as
fast
as
possible.
Then
that's
why
you
want
to
rely
on
some
tools
that
provided
by
other
companies
and
built
by
other
people,
especially
in
the
form
of
apis.
A
But
then,
when
you
use
these
apis,
you
basically
locked
in
into
a
proprietary
databases
like
proprietary
companies
that
own
these
databases
that
provide
API
and
then
like
they.
They
control
the
access
of
of
yours
to
their
API
and
then,
if
they
don't
like
you
anymore,
they
can
just
cut
the
access
at
any
moment
and
your
application
just
stops
working
and
you
have
no
like
really
no
control
over
it.
A
This
happened
to
Twitter
that
happened
to
Facebook,
and
you
know
a
lot
of
such
cases
in
in
web
space
and
also
like
on
the
infrastructure
level.
You
don't
want
to
be
locked
in
into
particular
cloud
provider
and
there's
a
lot
of
stories
that,
like
even
if
people
were
happy
with
some
cloud
provider
who
are
happy
with
the
pricing
with
the
tooling,
but
when
their
business
starts
growing.
A
The
pricing
may
not
be
good
enough,
but
they
already
created
so
much
things
on
the
proprietary
stack,
so
it's
too
expensive
to
switch
so
people
paying
like
Amazon
a
lot
of
money,
especially
when
their
business
grows,
but
it's
just
at
the
same
time
it's
just
too
expensive
to
rebuild
everything
on
on
the
other
Cloud,
so
they
they
never
switch
like.
Sometimes
it's
just
very
painful,
but
in
web
tree
we
have
actually
like
in
web
tree.
A
A
But
in
fact,
a
lot
of
people
basically
like
because
the
in
in
particular
case
of
blockchains
and
blockchain
data,
the
data
is
organized
on
blockchain
nodes,
in
a
very
specific
way
that
usually
it's
not
very
convenient
for
you
know
doing
some
queries
or
particular
data
extractions
from
it.
So
people
create
apis
on
top
of
blockchain
data,
and
these
apis
are
basically
like
some
code,
Sitting
In,
traditional
cloud
and
it's
centralized.
A
A
You
know
there
are
obvious
limitations
of
the
chain,
so
you
cannot
put
like
the
application
fully
Unchained.
There
was
always
some
smart
contracts
on
chain.
There
also
is
some
back-end
sitting
in
the
cloud
in
Amazon
doing
some
indexing,
API
user
data
and
stuff
like
that,
and
you
know
there
are
a
lot
of
interesting
stories
like
when
the
dial
makes
a
decision.
A
You
cannot
really
enforce
the
code
sitting
in
Amazon
to
follow
this
decision
of
the
dollar
so
like
if
I.
If
the
dial
wants
to
update
the
the
off
chain
application,
that's
actually
not
really
possible
to
do
directly.
You
need
to
bring
someone
who
is
admin
of
this
Amazon
account
to
go
to
login
and,
to
you
know,
roll
out
the
update
after
the
dial
made
a
decision.
So,
like
you,
have
this
disconnection
which
may
lead
to
like
really
just
the
down
like
managing
applications.
A
Biologist
doesn't
give
you
its
real
value
in
this
case,
yeah
and
and
again.
So
this
is
the
point
about
like
apis
that
built
on
top
of
blockchain
data.
There
are
like
many
of
them.
There
are
nfts
apis,
like
you
know,
apis
for
for
the
wallets,
D5,
apis
and
stuff
like
that
and
like
if
you,
if
you
build
on
it,
you
have
again
the
same
problem,
your
subject
of
the
login
and
the
access
can
be
disabled.
Even
if
these
guys
are
cool
and
great
and
they're
in
battery
Community.
A
A
So
the
way
we
see
kind
of
how
to
solve
it
like
we
need
some
sort
of
peer-to-peer,
decentralized
Computing
that
would
be
somewhere
between
centralized
Computing
and
on-chain
computing.
That
would
also
will
have
no
middleman,
no
as
as
blockchain,
but
will
not
have
redundancy
and
like
cost
like
high
cost
like
like
launching
computer,
and
it's
basically
like
super
useful
for
many
use.
A
Some
you
know,
may
have
some
even
use
cases
that
haven't
existed
before,
like,
for
example,
like
the
file
coin
example
with
the
ceiling
Computing
job,
which
you
want
to
probably
run
on
decentralized
infrastructure
instead
of
centralized
so
and
the
approach
this
with
fluence
and
the
best
way
to
think
of
fluence
is
it's
analogy
of
the
cloud,
but
it's
analogy
not
only
like
all
cloud
services,
but
mainly
analogy
of
serverless
stack
of
the
cloud
so
basically
to
enable
this
serverless
stack.
We
have
we
built
a
development
platform
with
all
the
tooling.
A
We
go
to
the
network
where
these
developer
development
platform
runs
and
the
network
is
the
Open
Marketplace
of
providers.
Anyone
can
join.
Anyone
can
run
a
note.
Anyone
can
be
provider
on
this
network
and
be
part
of
development
platform,
and
it's
all
kind
of
works
together
with
the
economic
model.
So
development
development
platform
is
basically
I
can
I
can
yeah
I
can
skip
it.
A
A
Basically,
we
built
our
own
tooling
for
the
distributed
workflows
that
can
orchestrate
this
execution
of
the
functions
and
we
kind
of
and
kind
of
we
try
to
enable
all
these
simple
pieces
that
allow
you
to
build
whatever
back-end
business
logic
you
want,
and
the
the
workflow
part
is
important
because
we
are
trying
to
like
when
you
build
a
more
or
less
complex
backend.
It's
always
contains
from
from
some
pieces,
and
if
you
wanted
to
scale
you
end
up
with
this
design
contains
of
two
things
you
can.
A
You
have
the
piece
of
code
to
execute
and
you
have
some
business
Logic
on
top
of
several
pieces
of
code
and
how
they
work
together
and
what
happens
if
something
fails
or
we
need
to
paralyze
something
and
stuff
like
that
and
usually
in
in
the
cloud
you
have
this
design.
So
so
you
have
a
centralized
API
Gateway,
where
all
the
HTTP
requests
from
the
clients
come,
and
then
this
Gateway
orchestrates
the
request
to
a
bunch
of
microservices,
and
it's
all
works
perfectly.
A
But
the
problem
is
someone
needs
to
own
and
run
this
API
Gateway
and
if
you
wanna
try
to
like,
if
you
want
to
avoid
this
gateway,
then
we
need
something
very
different
so
and
what
we
created
is
something
that
that
works
very
differently.
So
that's
the
basically
protocol
and
the
programming
language
that
allows
you
to
create
and
run
any
distributed,
workflows
or
network
algorithms
like
this
one,
for
example
this
example.
A
Don't
have
any
coordination
or
like
a
Gateway
here
where
I
need
to
look,
you
know
which
keeps
the
list
of
nodes
or
which
keeps
the
list
of
like
the
order
of
the
execution.
So
this
script
is
basically
put
into
the
data
packet
that
initiated
by
the
first
user
and
every
node
has
the
runtime
that
can
parse
this
script
and
say:
okay,
I
need
to
execute
this
part
and
then
I
put
like
add
the
result
to
the
data
packet
and
then
I
send
it
further
so
yeah.
A
They
may
contain
plague
plugins
with
the
data
networks,
like
with
storage
networks,
with
like
external
they
can
access
external
world
like
we
are
Legacy
HTTP
calls
they
can
access,
blockchains
and
stuff
like
that.
So
basically,
on
every
on
any
node,
you
can
run
a
function
that
can
you
know,
take
data
somewhere,
do
some
work
and
put
data
somewhere
else
or
put
data
to
the
output
request
and
the
experience
of
it
like
it's,
it's
very
similar
to
the
to
the
serverless
stack.
A
A
But
it's
it's
something
that
just
just
we
need
to
build
as
a
part
of
the
platform
and
which
will
be
built,
as
a
part
of
you
know,
Aqua
language
as
a
like
libraries
of
the
language,
basically
yeah
and
again,
like
some
some
basic
features
available
already.
Some
like
data
adapters
available
already
and
a
lot
of
things
that
looks
more
familiar
on
the
level
that
you
used
to
see
in
the
cloud.
A
So
it's
a
very
it's
a
very
nice
and
developer
tooling.
That
is
like
targeted
for
creating
distributed
algorithms,
so
you
can
create
whatever
algorithms
you
run
on
a
backend
and
very
important
topic
about
secure
model
of
all
of
this,
and
basically
like
in
in
blockchain
by
default.
You
have
secure
model
security
model
of
the
consensus.
So,
basically,
like
you
have
some
computation
you
deploy
to
a
network
and
then
every
node
has
to
repeat
it,
and
every
node
has
to
get
the
same
result
and
that's
why
it's
so
expensive.
A
That's
why
it's
so
slow
and
and
stuff
like
that,
so
fluents
by
default,
does
not
apply
consensus
on
the
computation
so
like
by
default.
It's
basically
trusted
computation
right
now,
so
you
deploy
a
function
to
the
node
and
then
you
trust
that
the
node
executed
it
correctly.
There
is
a
thing
called
truss
graph
that
we
have,
which
is
something
similar
to
the
concept
of
web
of
trust.
It
means
that
if
I
know
some
Authority
and
this
Authority
trusts
this
node,
then
I.
A
Maybe
should
trust
this
note
because,
like
it's,
it's
like
some
other
people
say
and
it's
trusted,
but
obviously
that's
not
enough.
If
you
want
to
have
like
proper,
verifiable
decentralized
computations,
and
what
we're
allowed
to
do
is
to
like
its
optionality
so
like
if
the
consensus
based
computation
is
fine
for
you
in
terms
of
cost
and
performance,
you
can
apply
consensus
to
execution
some
function
and
you're
gonna.
A
It's
I
mean
it
depends
a
little
bit
on
the
ZK
proves
generation
but
like
there
are
ways
to
to
optimize
this
stuff.
It's
like
this
area
progresses
pretty
fast,
now,
Yeah.
So,
basically,
like
this
development
stack
runs
on
the
network
and
the
network
is
heterogeneous.
Basically
like
every
node
is
different.
Every
node
is
a
hosting
provider
and
like
every
node,
runs
different
functions,
whatever
it
allows
to
run
on
their
Hardware
and
yeah.
A
So
we,
if
you
have
such
a
network,
if
you
have
such
development
stack,
we
can
really
build
applications
and
apis
that
you
know
can
be
not
really.
Can
can
have
similar
capabilities
like
applications
on
chain,
where
you
have
this
separation
between
author
or
the
application
who
create
smart
contract
and
the
network.
That
runs
the
application
it's
like,
if
the
if,
for
example,
I
have
the
like
and
basically
blockchain,
have
this
feature
of
forking
like
right.
A
If,
if
some
part
of
network
disagrees
with
update
that
developers
pushes
the
network
works,
and
here
you
can
have
such
sort
of
application,
Forks
like
if
I
run
some
application
on
some
nodes
in
the
fluence
network
and
then
I
want
to
you
know,
you
know,
create
the
update
and
deploy
the
update
that
the
users,
don't
like
the
users
can
say.
Okay,
like
we
are
forking
the
application
we
are.
A
We
keep
running
the
older
version
on
the
notes
that
that
it
was
available
before
and
the
new
version
maybe
will
also
be
adopted
by
some
other
nodes.
But
that
creates
a
lot
of
flexibility.
So
in
terms
of
like,
if
there
is
a
version
of
some
application
that
has
demand
the
user
demand
for
it,
it
will
exist
while
it
has
demand
so
like,
while
some
people
are
ready
to
pay
to
nodes
for
hosting
this
version
of
application,
regardless.
What
the
original
author
of
this
application
thinks
or
does?
A
This
version
may
exist
and
may
be
available
for
users,
and
this
is
some
state
of
things.
So
the
we
have
the
network
up
and
running
right
now
and
and
the
like
you,
you
can
do
some
basic
stuff
with
that
the
be
launching
like
we
want
to
launch.
We
want
to
have
the
the
dial
to
make
the
network
to
be
governed
by
the
Dow.
This
is
should
come
this
year,
but
you
know
with
this
Market
we
we're
kind
of
not
sure
yet
and
we
will
work
with
work.
A
A
lot
on
the
all
of
this
incentives
and
the
economic
model
and
the
the
proofs
because,
like
it's
all
connected
like
the
the
proofs
of
computations,
is
tied
to
reward
for
the
computation,
because
we
want
only
a
pay
to
those
nodes
who
executed
the
code
correctly
and
that's
why
we
need
the
the
proof
of
computation
for
enabling
the
the
payments
on
on
the
network.
We
don't
want
to
rely
on
just
reputation.
A
Yeah
so,
like
the
economics
is
very
interesting
topic
because
you
can
not
only
just
have
the
payments
for
computation.
You
can.
You
know
play
with
this
a
lot
of
unchain
Primitives
to
like
enable
even
some
sort
of
defy
on
top
of
computational
workloads
and
stuff
like
that-
and
there
are,
you
know
several
other
interests
in
things
here
that
that
can
be
enabled.
For
example,
the
whole
thing
runs
like
a
you
know:
decentralized,
open,
Cloud,
where
there
are
compute
providers,
there
are
some
application
developers
and
there
is
some.
A
A
The
clouds
gonna
adopt
it
and
they're
gonna
extract
all
the
money
they
can
and
they
are
not
really
incentivizes
to
incentivized.
To
pay
you
anything
back,
and
here
we
can
enable
like,
because
we
have
this
link
between
where
Revenue
goes
and
which
you
know
which
pieces
of
applications
generate
revenue
for
the
nodes.
A
We
can
extract
the
small
part
of
this
Revenue
stream
and
send
it
to
the
authors
of
this
useful
pieces
of
applications
such
as
database
or,
like
maybe
like
libraries
stuff,
like
that
they've
been
reused
across
different
applications
and
you
as
an
open
source
developer,
can
like
really
build
continue,
building
the
open
source
product
and
get
a
fraction
of
cloud
Revenue,
which
is
super
cool
yeah.
So
this
is
just
a
link
to
some
Network
dashboard.
Like
it's
still
kind
of
you
can
you
can
call
it
test
net?