►
From YouTube: Developer Community Call
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
Slowly,
start:
okay,
hi
everyone
again
good
to
see
you
all
good
to
hear.
You
all
see
your
reactions.
This
is
the
developer
community
called
by
weekly.
A
Yeah
bi-weekly
developer
call
fluence
core
team
and
the
community
you
guys
we
can
start.
If
we
have
any
updates,
we
can
start
with
updates
and
then
q
a
any
questions
you
have
and
if
anyone
has
the
demo
from
the
community
very
welcome,
you
can
show
work
in
progress
share
anything
you've
been
working
at.
We
can
share
some
feedback
and
you
know
just
let's
keep
it
informal
and
let's
have
just
nice
time
during
this
hour,
and
then
we
have
alexey
today.
A
Colleagues,
who's
gonna
give
us
some
updates
on
the
note
right.
What
what
was
the
topic?
Maybe
you
can.
B
A
Cool
yeah:
do
you
have
any
updates
from
the
core
team
today
dmitry.
C
Hello,
well,
actually,
we
don't,
because
we
are
focused
on
stabilization
and
it
means
that
under
the
hood,
everything
is
a
better
every
day,
but
the
only
experience
is
that
it
just
works
as
expected.
C
So
a
lot
of
bug
fixes
really
a
lot,
and
maybe
alexi
will
tell
about
some
of
them
or
like
like
that,
and
we
are
doing
some
r
d,
which
will
take
effect
later
and
it's
mostly
around
introducing
fluency
li,
the
new
tool
that
will
cover
the
development
life
cycle
of
of
the
films
project
and
that
will
be
like
an
umbrella
tool
for
all
the
routines
that
developers
usually
face
when
trying
to
develop
application
working
on
the
project
with
the
code
name
spells,
which
is
the
effort
to
make
scheduled
scripts.
C
C
A
Awesome,
thank
you
so
much
that
was
quite
an
update
on
the
community
side.
I
can
say
that
we
are
thinking
if
we
are
joining
east,
prague
and
prague
blockchain
week,
which
is
happening
in
the
beginning
of
june
5th
to
12th
of
june.
There
will
be
a
hackathon
by
local
local
community
and
the
week
of
events,
so
we
are
just
considering
that
option
and
then,
for
the
summer
in
july
there
is
barcelona,
east
barcelona,
the
conference
and
maybe
they're
they're,
organizing
hackathon.
A
They
don't
know
yet
the
organizers,
so
we
will
know
about
it
in
a
few
days
next
week.
So
we're
joining
that
we
are
planning
to
do
a
hacker
house
and
a
couple
of
events
during
the
week
and
we'll
be
inviting
other
projects
to
host
their
events.
There.
That's
the
the
plan
and
the
same
for
paris,
ecc
and
blockchain
week
in
paris,
that's
more
technical
and
yeah.
So
that's
the
that's
the
news
and
for
the
for
august
we
are
going
to
organize,
probably
dbap
camp
co-organized
with
internet
archive.
A
A
All
right.
Does
anyone
has
any
questions?
Maybe
we
go
with
a
q,
a
first
anything
or
any
work
in
progress.
Anyone
wants
to
share.
D
I
had
one
question
with
regard
to
our:
we
had
a
conversation
this
afternoon
and
I
I
was
having
questions
about
how
to
integrate
like
notes
of
other
peer-to-peer
networks
like
ipfs
and
ethereum,
and
everything,
and
then
in
marine.
There
is
the
macro
which
does
the
binding
to
how
you
call
it
like
this
link
was
an
import
module
and
then
we
talked
about
it.
But
my
question
was
the
host.
That
is
the
docker
container
of
the
flow
of
the
fluence
note.
Or
is
it
the
the
server.
B
Well,
it
depends
on
how
you
run
the
clearance.
If
you
run
it
in
the
docker
container
like
the
default
setup,
that's
the
default
setup,
then
it
will
look
for
binaries
in
docker
containers
or
so.
In
that
case
the
host
will
be
docker
container,
but
nothing
really
stops
you
from
running
fluence
without
docker
it.
It's
not
required
at
all.
Fluency
is
rather
simple.
You
just
run
it
and
give
it
configuration
file
and
that's
it.
Yeah.
B
D
But
you
could
also
just
use
the
curl
to
go
to
the
local
host
of
the
server
and
then
make
the
call
to
the
likes
saying
ipfs
note:
that's
basically
outside
the
fluence,
so
you
have
your
internal
ipfs
node
with
fluence,
and
then
you
have
your
sort
of
external
but
which
is
still
a
local
host
yeah.
I
was
also
thinking
about
that.
So
then
you're
still
using
curl
but
you're
not
doing
a
dns
lookup.
D
So
it's
it
would
still
be
sort
of
decentralized
in
the
sense
that
you're
not
using
the
tns
to
find
where
the
server
is.
B
Yeah,
that
makes
sense
and
more
to
that,
you,
you
were
not
required
to
use
curl
since
fluence
node
already
has
ipfs
client
binary.
You
can
just
use
it
and
the
default
aqua,
ipfs
library
that
we
have
in
aqua.
It
has
the
ability
to
work
with
external
ipfs
node
yeah
it
can.
It
can
work
with
that.
D
A
Yeah,
just
just
hello,
ryan
hi.
If
you
have
any
questions
you
can
drop,
it
also
yeah
very
welcome
first
time
joining
yeah,
just
just
wanted
to
remind
and
to
let
you
know
if
anyone
wants
to
start
project
with
fluence
building
with
fluence
or
have
any
ideas
feel
free
to
reach
out
to
us
in
any
channel
reach
out
to
me
and
dm,
we
really
like
we.
A
We
are
very
helpful
when
we
we
would
be
happy
to
help
you
if
you
have
any
anything
so
yeah,
don't
afraid
to
ask
for
support
okay.
So
if
there
are
no
questions
so
far,
maybe
alex
say
you
can
you
can
take
it.
Take
a
board
yeah.
B
B
We
finally
switched
from
our
fork
of
three
free
p2p2,
vanilla
to
upstream
p2p,
and
it
brought
some
api
changes
which
were
still
debugging
and
finding
bugs
and
stuff
like
that.
So
there
was
a
funny
little
bug
and
another
one
and
then
another
one,
so
connectivity
should
be
better
right
now
than
it
was
like
a
month
ago.
B
So,
if
you
have
any
connectivity
troubles,
let
us
know
okay,
so
my
idea
today,
for
today
demo
don't
be
scared
for
for
this
much
code.
I
will
write
it
like
in
in
a
separate
file
from
right
beginning.
My
idea
for
today
demo
is
to
go
through
this
aquascript
and
write
it
and
explain
what
I'm
doing.
B
So
the
idea
is
that
we
have
some
node
some
peer
influence
network
and
we
want
to
check
whether
it's
reachable
from
other
peers
on
the
fluence
network
like
for
example,
it
can
can
come
handy
if
you
have
like
your
own
fluency
network
or
you
you're,
having
several
javascript
years
or
you're
having
like
you're,
maintaining
your
own
fluency
notes,
something
like
that.
B
So
that's
the
goal
of
this
script
and
let's,
let's
start
writing
it
like
in
a
separate
file
just
so
it's
not
too
much
code,
and
you
can
bear
with
me
through
the
through
through
the
whole
process.
So
first
thing
first,
I
I
don't
even
need
that
so
far,
first
thing:
first,
I
want
to
create
a
function
that
accepts
like
target
node,
the
node.
I
want
to
check
the
list
of
a
list
of
validator
nodes.
B
Those
are
the
nodes
that
will
check
if
my
node
is
available
and
I'm
out
it
sets
threshold
when,
after
which
we
think
of
node
as
unreachable,
so
so,
okay,
maybe
I
should
should
split
layout
like
this.
No,
I
didn't
want
that.
I
meant
single
and
I
meant
split
like
left
right.
B
Okay,
so
I
can
take
a
look
at
the
script
okay,
so
the
idea
is
to
let's
start
simple
and
let's
first
check
whether
we
can
return
something
from
the
function
and
if
it
works,
and
how
to
run
the
function
at
all
like
here.
We
return
a
list
of
strings,
so,
let's
check
if
it
works
first,
we
would
need
an
import
of
built-ins
of
aqua
built-ins.
B
It
has
some
type
definitions
like
pro
id
and
stuff
like
that
and
some
functions
that
we
will
find
useful
as
we
write
code,
but
it's
basically
a
default
import.
So
if
you
want
to
do
anything
you,
you
usually
want
to
have
this
import
in
your
file.
B
Let
me
make
it
a
little
bit
bigger,
so
you
can
hopefully
see
see
the
text,
so
I
have
this
demo
aqua
here
in
this
fall
in
this
directory.
So
let's
run
it.
I
pass
this
file
to
aquaran.
A
quran
is
a
tool.
Aqua
is
a
tool
that
allows
us
to
compile
aqua
code
and
also
run
it
right
away.
So
aquarium
is
what
you
want
to
use
it
when
you're
just
developing
aqua,
and
you
want
to
check
some
things
and
you
want
to
play
around
debug
something
or
just
try,
fluence,
that's
an
awesome
thing.
B
B
Yeah
because
we
didn't
pass
what
node
we
want
to
use
as
a
relay
since
fluency
is
a
network,
it's
an
open
network.
Anyone
can
join
it,
but
in
order
to
access
it,
you
need
to
have
some
entry
point
right.
It's
like
a
big
bunch
of
peers,
but
you
want
to
know
at
least
a
single
peer,
so
you
can
reach
it
and
say:
hey.
Please
run
this
aquascript,
so
in
a
in
our
case,
we
can
take
like
first,
our
first
node,
but
it
still
doesn't
work
because
why?
B
Because
we
didn't,
I
didn't
pass
arguments
to
the
function
and
it
says
that
it
expected
it
expected
three
arguments,
but
we
passed
zero.
It.
Actually
you
see
it's
about
it
reports
incorrectly
number
of
arguments.
It
gets
messed
up,
okay,
so
first
we
need
to
pass
target
node,
then
validator,
nodes,
then
time
out.
B
How
do
we
do
that?
Let's
do
that
like
this
validator
time
out,
but
this
won't
work
right
away
because
the
those
variables
will
be
just
undefined
for
them
to
have
some
value.
We
need
to
pass
it
as
json
like
target
is
for
now
I
will
just
put
placeholders,
but
then
I
will.
B
B
Okay
and
we
got
our
test
data
back,
so
it
works.
Aquaran
works.
That's
nice!
That's
always
nice
when
something
works.
So,
let's,
let's
remember
what
we
are
here
to
do.
The
goal
is
to
check
check
that
target.
Node
is
reachable
from
validator
from
each
validator
yeah.
B
That's
our
goal.
For
that
to
to
reach
the
goal.
We
first
need
to
decide:
what's
our
target
node
and
what
are
our
validator
nodes
influence
in
aqua?
B
We
have
this
thing:
config
default
peers
that
gives
us
a
list
of
peers
that
we
can
use.
It's
like
appears
maintained
by
fluence.
It's
just
hard
code,
at
least
here
in
in
the
tool,
just
just
a
nice
thing
to
always
have
your
addresses
to
copy
paste.
But
actually
there
are
more
appears
in
the
network
and
we
can't
hardcode
them
into
our
tool
because
they
join
they
leave
and
stuff
like
that.
But
this
one
are
stable
and
others
are
stable
too,
but
this
one.
So
we
know
we
maintain
them.
B
So
we
have
coded
them
here.
So
it's
easier
to
to
copy
paste
it
as
we
go.
So,
let's
copy
paste
it
all
what
we
need
from
those
peers.
So
you
see
this
is
kind
of
a
network
address
that
starts
with
a
protocol
name
then
domain
name
then
protocol
for
networking,
then
number
of
the
port
and
finally
protocol
that
we
will
use
on
top
the
tcp
and,
after
that,
peer
id,
it's
kind
of
basically
public
key
of
the
peer
that
we
want
to
use.
B
So
it's
kind
of
like
http,
semicolon
slash,
slash,
google.
A
B
So
let's
say
that
this
is
will
be
our
target
node,
and
this
will
be
our
validators
okay,
nice.
So
in
that
case,
what
we
want
to
do.
First,
we
want
to
check
whether
validators
themselves
are
available
from
our
relay
yeah,
there's,
also
a
notion
of
relay
like
entry
point.
Basically,
it's
an
entry
point
to
the
network
that
I
was
describing
before
we
can
choose
some
other
node
for
that
purpose
like
this
one.
In
that
case,
we
do
need.
B
We
do
need
our
networking
part,
because,
when
we're
connecting
to
the
network
to
the
entry
point,
we
need
to
know
where
to
connect
once
we're
connected
to
the
network,
we
can
operate
just
purely
on
peer,
ids
and
network
will
discover
them
automatically.
But
when
we're
just
connecting,
we
need
to
know
to
what
server
and
what
port
and
how
to
connect
to
the
okay.
So
we
have
our
validators
and
we
want
to
check
if
they're
ritual
at
all,
what
we
will
do,
let's
first
iterate
through
the
through
the
array
through
the
list
of
validators.
B
Right
and
here
we
need
to
go
to
validator.
We
have
this
on
thing
on
keyword
in
aqua.
It
tells
to
do
something
on
validator,
so
here
we
can,
for
example,
do
something,
but
what
we
want
to
do.
First
of
all,
we
want
to
return
some
data
right
before
it
was
test
like
abc,
but
now
we
need
to
start
start
returning
some
real
data,
so
let's
define
a
stream
of
results,
results
yeah
and
let's
write
something
there.
B
Will
it
work
let's
and
we
can
return
results
from
here.
So
what
we're
doing
here
we're
going
through
all
validators
we're,
making
a
topology
hope,
like
a
network,
hope
to
the
validator
on
the
validator.
B
B
B
B
Let
me
increase
the
timeout
from
seven
seconds
to
like
20
seconds.
I
wonder
why
timeouts
shouldn't
shouldn't
turn
out.
B
Oh
yeah
you're
right,
so
this
is
a
kind
of
yeah
right,
and
so
I
don't
return
anything,
but
it
still
should
have
worked,
should
work
and
return
yeah
and
now
now
it
complains
yeah.
That
makes
sense.
B
Okay.
What
should
we
do
about
that?
We
should
just
put
it
like
this,
like
hello,
hello,
and
do
it
like
this.
So
what
happened
here?
Op
identity
is
a
function
that
looks
like
this,
so
we
have
a
service
op
and
we
have
a
function
identity.
There.
B
B
But
result
expects
just
a
stream
of
strings,
so
we
can't
easily
write
the
optional
string
back
to
results.
So
what
I
do
is
I
crea.
I
make
just
string
from
optional
string
by
using
this
operator.
Exclamation
mark
it
doesn't
mean
anything
yeah,
so
in
this
case
it
converts
from
optional
string
to
just
string.
So
let's
try
if
it
works,
I
hope
it
yeah
and
we
need
whoa
whoa
and
we
need
to
do
like
that.
B
B
B
B
B
Okay,
I
think
this
is
far
more
readable
than
before.
We're
calling
checking
on
this
up
from
file
demo
dot
aqua
and
we're
passing
this
json
to
aquaron.
So
it
can
like
use
those
variables
right
away
in
the
function.
Call
right,
y,
okay,
great!
So,
let's,
let's
run
the
command
again
to
check.
If
I
did
it
correctly,
okay,
we
have
our
hellos
nice.
So,
let's
make
it
more
meaningful.
We
can
return
instead
of
like.
Instead
of
doing
this
thing
and
returning
hello,
we
can
do
a
special
operation
that
does
nothing
it's
called
op.
B
B
Okay,
I
think
my
cat
drank
from
that
cup,
I'm
not
sure,
okay,
what
we
want
to
write
here,
I
want
to
write
a
validator
address,
so
this
way
we
will
would
be
sure
that
we
went
through
each
validator
right.
So
this
is
a
script
that
goes
through
each
on
each
validator,
writes
its
address
to
the
stream
and
returns
the
stream.
B
Okay,
nice,
let
me
clear
the
terminal
run
it
again,
so
it's
more
easy
to
read.
So
I
run
this
comment
and
I
get
this
result.
So
we
went
through
each
of
the
validators
this
one
this
one
and
we
returned
their
addresses
back.
So
that's
already
great,
that's
already
a
distributed
algorithm,
maybe
a
very
simple
one.
B
B
Validator
is
reachable
right
and
return
status
is
here.
What
will
happen
we
will
have
as
a
result,
we
will
have
array
of
two
strings
of
two
messages.
Validator
is
reachable
not
much
sense
in
that,
because
we
won't
know
which
word
the
validators
are
reachable
right.
We
want
to
to
add
an
address
of
the
validator
to
the
status.
How
do
we
do
that.
B
In
built
in
aqua,
there
is
a
service
op
right
that
has
an
identity,
but
also
it
has
a
function.
That's
called
concat
strings
that
accepts
actually
any
number
of
strings
under
the
hood,
but
in
aqua
we
don't
have
means
to
express
that.
So
in
order
to
use
concat
strings,
you
usually
have
to
redefine
service
right
so
and
say
how
many
arguments
you
want
to
concatenate.
You
just
have
to
do
that.
So
I
want
to
concatenate
two
strings
here
or
no.
B
I
want
to
concatenate
three
strings,
so
a
b
c
string-
and
I
want
to
do
it
like
this
op
string,
concat
strings
validator
validator
like
I
need
space
here-
is
reachable,
so
it's
kind
of
not
not
very
good
visible
like
this,
so
I
concatenate
those
three
strings
for
one
two:
three
and
get
a
status
from
from
the
function.
Let's
take
a
look
how
it
works.
B
B
B
But
what
will
happen
if
we
pass
a
node?
That's
not
reachable.
Let's
try
like
I
have.
I
know
that
xxx
isn't
a
real
peer
id,
so
it's
not
reachable
for
sure.
So,
let's
try
to
do
that.
What
will
happen?
Actually,
we
already
know
what
will
happen.
It
will
just
time
out
after
20
seconds,
it's
very
really
a
lot
of
time.
B
So,
let's
put
it
like
one
one
second,
for
now,
I
think
it
will
be
better
but
due
time
out,
dude,
I'm
out
yeah,
so
it
did
timed
out
after
one
second
will
be
faster
great,
so
we
don't
have
any
way
right
now.
We
don't
have
any
way
to
tell
that
like
to
to
return
status
unreachable,
but
we
need
to
have
one
right
for
this.
We
have
a
pattern
called
race.
It's
described.
Actually
it's
described
on
fluence
dev,.
B
A
B
B
We
have
a
this
function,
what
it
does
it
sleeps
for
this
amount
of
milliseconds
and
then
returns
the
string
that
you
have
passed
there,
so
how
it
works
and
what
happens
so
we
have
basically
two
two
things:
two
things
that
raise
each
other.
We
have
this
block
of
code
that
goes
to
validator
does
operation
that
does
nothing
and
returns
status
back
and
if
validator
isn't
reachable.
B
This
will
take
a
lot
of
time
like
forever,
unless
we
put
a
timeout
on
that,
and
the
second
branch
of
of
this
like
racing
pattern
is
this:
it
will
run
for
exactly
one
second
and
then
return
string
timeout.
B
So
if
we
do
it
like
this,
we
write
two
statuses:
either
this
status
or
a
string
same
out,
it
will
be
who
who
is
faster
like
who
who's
faster,
that
will
write
the
status
first.
Let's
do
that
and
see
what
happens.
B
We
have
like,
I
added
three
validators
and
first
one
time
it
out.
So
we
see
that
it
timed
out,
but
we
don't
see
like
it's
peer
id
or
it's.
It's,
not
a
very
good
user
experience.
Let's
improve
it
a
little.
Let's
do
very
same
thing,
but
here
I
wonder
if.
B
D
I'm
gonna:
can
I
interrupt
with
a
question
yeah
sure
sure:
don't
why
on
line
11,
is
it
like
a
double
arrow
back
and
on
12
a
single
one.
B
So
before
it
was,
it
was
like
like
this
right
and
when
you
write
a
usual
value,
just
the
value,
just
a
constant
value
to
the
stream.
You
have
to
use
this
operator,
but
when
you're
using
a
function,
you
have
to
use
this
separator
yeah
yeah.
So
this
or
this
doesn't
really
matter.
I
believe
it's
a
kind
of
bug
in
a
parser
so
before
it
was
two
different
operations,
and
now
it's
not
maybe
dmitry
wants
to
add
something
to
that.
D
So
yeah,
because
I
was
thinking
if
it's
a
surface,
I
have
to
do
it
like
this
and
if
it's
just
a
string,
I
can
use
the
double
ones,
but
it
it
works
with
the
surface.
It
works
with
the
double
ones
as
well.
D
Yeah
yeah
and
I
just
learned
the
the
thing
with
that.
I
have
to
rename
this
up
surface.
B
D
B
Yeah,
it's
a
very
powerful
technique
that
comes
from
to.
B
B
Whatever
you
call
it,
but
just
make
sure
to
put
the
correct
service
id
here
and
then
you
can
define
identity
that
takes
like
number
and
return.
I
mean
you
32
32
and
return
c32.
It
will
work
because
under
the
hood,
it's
what's
the
word
for
it.
It's
a
general
function
like
polymer
polymorphic
function
that
accepts
any
type
of
argument
and
returns.
It
back,
but
aqua
doesn't
yet
know
how
to
do
that.
How
to
express
that.
So
we
have
to
have
this
approach
of
overloading
services.
D
B
Okay,
I
think
15
minutes
is
enough.
So,
okay,
we
have
this
thing.
It
checks
whether
our
validator
is
reachable
or
not,
but
actually
doesn't
really
work.
Well.
So
first
error
is
that
I
hardcoded
time
out
here.
B
B
Nope,
of
course,
and
if
we
remove
this
thing
and
if
we
run
it,
you
see
that
all
validators
timed
out,
I
guess
sometimes
we
will
see
different
messages
now,
it's
too
fast.
Let
me
what
I
want
to
show
you
is
that
in
this
case
it's
kinda.
B
What's
the
word
for
it,
you
you
can
say
what
will
happen.
You
can
see
what
will
happen,
because
both
this
operation
writes
to
the
stream
and
this
operation
writes
there
too.
So
it
may
happen
that
this
separation
road
and
then
this
separation
also
added
a
value.
B
So
even
if
you
pass
two
validator
nodes,
you
can
can
have
up
to
four
statuses
because
both
of
the
separation
right
to
the
same
stream
and
it's
non-deterministic,
which
which
order
it
will
happen
in
which
order
it
will
happen
so
how
to
cure
that
how
to
cure
that
we
introduce
status
like
like
validator
status
variable.
It
can
be
actually
like
this,
but
there's
no
difference
not
much
difference.
We
put
it
like
this
so
and
we
don't
right
now
you
see
we
don't
write
anything
to
statuses,
so
statuses
will
always
be
empty.
B
Only
validator
status.
We
should.
We
should
do
it
like
this.
Only
validator
status
will
be
filled
with
either
this
value,
or
this
like
this
value,
or
this
one
or
both
of
them.
You
can
say
how
it
will
be,
but
what
you
can
say
is
that
which
one
is
first,
it
wins
like.
You
can
say
that
which
one
is
fastest
will
be
the
first
one.
B
B
We
write
validator
status,
the
first
one
first
validator
status
to
the
status
stream.
So
this
way
right,
yeah
correct
this
way.
What
we
do
is
we
always
make
sure
that
only
single,
the
first,
the
fade
status
will
be
written
to
the
only
the
the
single
status
will
be
written
to
statuses
stream
for
every
validator,
so
we
always
will
have
invariant
that
there
is
as
much
status
as
there
are
validated
nodes.
B
B
B
B
Okay,
great
so
this
works,
and
you
see
somehow
this
node
meant
to
time
out,
even
though
it
has
whole
two
seconds
to
respond.
Maybe
it's
under
the
load
right
now.
Maybe
that's
the
reason
we
can
increase
it
to
like
four
seconds,
but
still
okay,
nice
nice.
We
have
validators
checked
for
reachability,
and
now
we
can
go
and
check
our
go
and
check
our.
B
B
Like
this,
this
is
needed
to
overcome
to
overcome
a
bug
in
current
aqua.
Basically,
it's
a
like
it's
more
usability
kind
of
usability
issue
that
you
can't
write.
B
If
on
streams,
it
will
cause
bugs,
but
you
will
see
right
now,
so
we
saved
validator
status
to
variable
and
now
we
need
to
compare
now
we
need
to
compare
status,
but
we
actually
cannot,
or
can
we
yeah,
we
can
compare
it
so
if
west
equals
this
right
like
we
can,
we
can
even
move
it
to
some
variable,
but
whatever
so,
if
it
equals
this,
then
we
can
put
put
status,
write
status
to
status,
a
string.
Okay,
sorry,
a
a
little
bit
got
carried
away
by
by
the
code
on
the
left.
B
B
B
B
From
we
have
free,
well,
okay,
target.
B
B
From
validator
it's
a
little
bit
long.
I
can
do
that
like
this,
but
I
think
it's
less
reasonable,
but
you
know
that
this
is
not
reachable.
This
is
reachable.
So
I
guess
it's
fine.
Okay,
we
did
the
same
thing
and
now
we
need
to
so.
If
validator
was
reachable
when
validator
was
reachable,
we
checked
the
target
and
saved
its
status
in
case
validator
wasn't
reachable.
B
B
B
So
I
hope
this
will
work.
Let
me
do
it
like
this,
so
it's
easier
to
read.
Oh
at
least,
let's
try
to
run
it.
B
B
French,
no,
where
did
I.
A
B
B
B
Check
that
node
is
reachable
from
validator
from
that
validator
yeah,
so
yeah.
We
first
checked
that
validators
themselves
are
reachable.
Then,
if
valid
data
is
reachable,
we
checked
that
target
node
is
accessible
through
this
validator
and
we
reported
that
to
the
status
and
we
returned
array
of
statuses,
one
more
thing
that
we
can
improve
here
we
can
put
bar
here.
B
B
If
we
have
more,
it
will
be
more
parallel
checks,
but
if
we
do
so
we
must
be
careful,
because
if
I
just
run
it
you
see,
I
will
get
an
empty
result.
Let
me
let
me
do
it
again.
B
I
just
get
empty
result.
Why?
Because
we
added
par
here,
so
all
this
thing
completes
immediately
just
like
that
and
returns
immediately
and
it
it
didn't,
got
any
time
to
write
statuses
back.
So
we
need
to
wait
to
wait
for
statuses
to
be
reported,
but
how
much
statuses
do
you
want?
Do
you
want
like
10
of
them
with
one
validator,
so
we
probably
want
to
have
two
statuses,
but
since
we're
using
array
booklets
here
they
start
from
zero.
So
we
need
to
use
two
minus
one.
That's
one
index
one.
B
B
Yeah,
you
see,
we
have
three
validators,
so
I
need
actually
to
put
here
number
two,
like
the
we
are
waiting.
This
expression
says:
wait
for
array
statuses
to
to
have
element
with
index
two.
So
that's
like
since
it's
zero
index,
it's
like
this.
So
this
way
we're
waiting
for
three
elements.
Actually,
let's
run
it
again
and
we'll
see
yeah,
and
you
see
this
validator
keeps
timing
out
for
some
reason,
that's
good.
B
B
So
we
need
to
calculate
this
number
instead
of
hard
coordinate.
How
do
we
do
that?
We
have
op
array
length
here
and
it
can
work
with
pure
edges,
because
pure
ideas
is
just
just
strings,
so
we
do
this
and
we
calculate
a
length
of
the
validators.
How
many
validators
we
have,
and
we
subtract
one
so
to
account
for
index-
has
been
zero
based.
B
And
yeah
it
works
and
we
have
this
script
written
just
now
in
like
30
minutes
or
something
great,
I
think
great.
Do
you
have
any
questions
about
what
happens
here?
Anything
I
understand
was
kind
of
involved.
B
Okay,
that's
fine,
and
also
that's
fine.
That
was
it
that
was
it
that's
how
you
can
write
different
distributed,
algorithms
in
aqua.