►
From YouTube: Video 1 of 6: Baseline Protocol v0.1 Messaging
Description
The Baseline Protocol team takes you through the code of the v0.1 update.
Next video: https://youtu.be/lsZQwiE2glA
Go to https://baseline-protocol.org for more information.
A
So
welcome
this
is
the
baseline
protocol
version
0.1
review
session
with
kyle
thomas
is
just
myself
and
kyle.
Today,
john
walpert,
and
we're
going
to
be
going
through
on
walking
through
the
code
walking
through
the
versions
1
0.1
stack
and
with
that
kyle.
Let's,
let's
get
to
it,.
A
B
So
messaging
follows
the
pack
the
the
pattern
of
having
a
provider's
directory.
It
has
an
index
that
has
an
imessaging
service
in
it.
So
basically,
this
is
a
very
generic
interface
that
defines
a
set
of
methods
that
you
would
want
will
want
to
implement
to
support
any
any
any
other
messaging
provider
we
have
implemented.
If.
A
I
was
say:
yeah
say:
let's
pick
anybody
other
than
that,
because
nats
is
going
to
be
in
the
whisper
there.
What's
another
good
one.
What's
what's
one
of
your
favorite.
B
Config
we've
got
some
whisper,
we
may.
A
B
B
Yeah,
it
also
made
sense
because
the
radish
34
sam
did
a
good
job
of
implementing
the
the
interface
here
kudos
to
him
for
that,
and
then
it
was
basically
defecated
now,
but
it
was
still
okay.
A
B
B
Ideas
in
there
sure
well,
yeah,
no,
that's
fair!
So
basically
you
know
you
have,
you
know
you're,
basically,
just
loading
a
factory
and
then
that
service
from
from
from
so
let's
talk
about
the
mass
provider,
you
know
in
this
context.
A
B
Yes
and
that's
a
an
open
source
cloud
native
project,
it
was
started
by
derrick
carlson
back
when
he
was
working
on
cloud
foundry.
I
believe.
B
Yeah
yeah
absolutely
yeah
yeah,
so
so,
basically
that
you
know
that's
got
a
good
pedigree
coming
from
you
know
in
the
cloud
native
cloud:
it's
a
cloud
native
project
or
the
cloud
native
foundation.
It's
got
some,
you
know
it's
got
some
some,
some
really
it's
really
performance.
It's
been
it's
it.
It's
a
it's
sort
of
a
flexible
choice.
It
supports
kafka,
it
has
kafka,
binding
extension.
A
Wasn't
it
yeah?
It
was
owen
connelly,
a
guy
that
works
for
provide
now
who
who
first
identified
nasa's
a
good
candidate
for
this
right
just
to
just
to
give
credit
where
credit's
due.
B
I
will
give
oh
and
credit
for
for
the
echo
protocol
the
idea
behind
that.
That's
a
great
idea,
we'll
take
more
on
that
later.
Oh.
B
A
What
do
you
mean
by
that
kyle?
If
you
don't
mind
me
interrupting
there.
B
I
haven't
used
the
bridge,
yet
this
bridge
yet,
but
what
it
means
is
essentially,
you
can
run
that's
on
one
side
and
you
can
run
cache
on
the
other
and
it
should
work.
A
Okay,
but
it
was
I
I
got
that,
but
but
specifically
say
you
had
three.
You
know
eight
companies
a
b
and
c
that
were
baselining
right.
They
were
in
the
org
registry
and
they
had
set
up
some
kind
of
set
of
processes.
Workflow
and
they've
got
everything
set
up.
Are
you
saying
that
two
of
them
can
be
on
kafka
and
one
of
them
could
be
on
nats
or.
B
But
the
reason
why
that's
again
not
to
shield
maps
over
and
over
again,
but
its
architecture
is
more
peer-to-peer
than
other
it's
brokerless,
and
so
it
lends
itself
to
creating
a
mesh
network
which
is
exactly
what
we
need.
A
So
I
think
that's
pretty
understandable
yeah
now,
where
do
we
go
from
here.
B
So
that's
here's.
The
here's.
The
nas
service
implements
that
imessaging
service
interface
that
we
we
discussed.
You
know
connectedness,
it's
just
very
it's
very
generic.
It's
not
specific!
It's
you
know
it's
a
it's
just
a
way
to
pipe
messages
that
you
receive
on
your
on
your
on.
Your
stack
into
you
know,
dispatch
it
into
like
an
asynchronous
message
handler
more
or
less
so
you
could
basically
pull
in
a
protocol
message
and
then,
for
example,
you
ingest
the
protocol
message
and
dispatch
it
into
the
baseline
process.
A
A
We
don't
want
to
go
dive
deep
on
on
that's
I
mean
we
could
do
another
session
with
eric
on
that
and
that'd
be
cool
sure,
but
let's
talk
about
a
couple
of
edge
cases
or
edge
failures
right
because
with
messaging,
it's
all
about
that,
so
we'll
say:
you're
baselining,
a
purchase
order
off
of
an
msa
or
a
master
service
agreement,
which
is
our
canonical
use
case
or
alice
and
bob.
A
If
you
want
to
talk
about
that,
I
know
that's
your
next
demo
that
you're
going
to
talk
about
so
you
know,
you've
got
this
workflow
step
and
you've
got
to
get
it
confirmed
on
chain
before
the
next
workflow
step
happens.
Right,
yep,
your
your
counterparty's
servers
down
right,
yeah,
they're,
endpoints,
not
only
fun,
tolerant
but
but
long
periods
you
know
like
I
know
I
remember
one
of
the
things
that
the
court
of
flow
guys
are
really
proud
of.
Is
that
you
can
like
keep
a
thing.
A
B
Yeah
so
the
way,
the
way
that
the
way
that
there's
a
good
pattern
for
that
you
know.
B
Messaging
services
in
general,
or
good,
good,
back,
plane,
control,
plan
type
of
type
of
you
know
those
are
good
use
cases,
and
so
because
you're,
you
know,
you
really
want
to
create
a
pattern
in
when
you're
implementing
the
protocol
to
dispatch
messages
in
an
asynchronous
way
and
do
them
in
an
atomic.
B
You
know
item
potently
such
that
any
message
that
you
know
doesn't
get
re-delivered
or
any
message
that
doesn't
get
acknowledged
is
essentially
there
eventually
will
time
out
and
be
re-attempted
and
then
every
single
message
type
that
you're
implementing
can
have
a
different.
B
You
know
a
different
time
at
a
different
ttl
in
that
regard,
when
you
send
a
message
like
if
you
dispatch
a
message
through
the
messaging
service
using
the
messaging
pro,
you
know
the
messaging
package,
what
you
would
really
expect
is
for
when
it's
delivered-
and
it's
you
know
when
this,
when
this
side
of
the
wire
gets
it,
you
would
expect
it
to
be
acknowledged
over.