►
From YouTube: Governance and Project Management Discussion
Description
Team meeting with a wide-ranging discussion covering governance, modularization, updating the spec and other topics. Notes here: https://github.com/libp2p/pm/blob/master/meeting-notes/2018-11-08-governance-and-project-organization.md
A
So
you
know
you
sort
of
have
to
go
through
your
kind
of
filtering
process
and
you
know
make
sure
you're,
not
the
tranqs,
some
some
something
that
was
said
in
confidence
or
whatever
so
I
think
that's
what
I
think
that's
what
roll
is
getting
at
and
he's
also
read
that
a
two
pager
is
more
likely.
People
are
more
likely
to
read
that
so
yeah.
C
C
D
A
I'm
actually
hoping
that
that
other
people
will
pick
up
the
ball
here.
But
let
me
let
me
kind
of
restate
so
the
premise
of
having
a
governance
discussion
right
now.
So
we
we
have
a
growing
community
of
people
who
are
adopting
Lib
p2p,
either
as
you
like,
consumers,
like
users
of
the
library
or
they're
adopting
in
the
sense
that
they
want
to
write
their
own
language
implementations,
and
it's
not
really.
Well,
it's
not
realistic
and
also
I.
Don't
think
it's
a
good
idea
for
PL
to
try
to
sort
of
control.
A
All
these
different
language,
implementations
and
everything
that's
going
on
so
I
think
you
know,
and
a
lot
of
these
people
are
making
significant
bets
like
parity
is
really
betting,
a
lot
on
substrate
and
that's
based
on
live
p2p.
An
etherium
is
preparing
to
bet
a
lot
on
e
2.0,
which
is
bit
was
gonna,
be
based
on
the
p2p
and
I.
A
C
So,
at
least
on
the
that
ipfs
side
we've
been
holding
off
on
doing
things
like
governance
models
or
other
things
like.
We
definitely
know
that.
That's
something
we're
going
to
have
to
consider
and
think
about
in
our
future
and
and
we've
been
relying
on
the
fact
and-
and
it
works
so
far-
that
this
is
a
fully
open
source
project.
C
You
know,
if
someone
doesn't
like
the
direction
it's
headed,
they
can
copy
it
and
start
doing
it
themselves
and
have
their
own
model
of
it,
and-
and
that's
like
you
know,
the
benefit
we
get
from
open
source
is
like
yeah
we're
not
gonna
yank
this
out
from
under
your
feet.
We
literally
cannot.
It
is
an
open
source
project.
We
can't
take
it
away
from
you.
C
It
sounds
like
it's
actually,
a
slightly
different
thing
of
like
well.
Is
development
gonna
happen
on
the
stuff
that
I
am
betting
on
the
stuff
that
I
need
for
my
business,
that
is
relying
on
this
product
on
the
cadence
and
and
in
the
way
that
I
need
it
to
happen.
If
I
am
NOT,
you
know
also
involved
in
the
decisions
that
are
happening
in
the
way
things
are
getting
added.
C
A
A
E
Yeah
so
Tamales
point
I
would
say
that
the
big
difference
here
is
that
you
know
99%
of
the
development
right
now
and
IVFs
is
done
by
protocol
labs
and
everybody
else
is
effectively
a
consumer,
and
so
they
need
to
know
where
I
guess,
I
supplied
enough
to
figure
out
how
they
depend
on
it.
The
people
that
are
showing
up
to
the
p2p
right
now
we're
showing
up
with
development
resources.
They
are
like
willing
to
solve
their
own
problems
as
long
as
that.
E
As
long
as
there
is
a
governance
model
that
will
take
in
those
changes
and
that
they're
not
going
to
get
over
by
like
the
direction
of
the
project
in
the
future.
So
there's
not
like
a
dependency
chain
where
they're,
just
like
waiting
on
other
people
to
do
work,
they're
willing
to
do
the
work.
They
just
need
to
know
that
it
will
actually
land
they
have
what
they
got
to
the
table.
E
At
that
point,
I
have
a
couple
questions
about
sort
of
the
people
that
are
adopting
and
how
they're
dot
there.
One
is
like
for
the
people
that
are
adopting
it.
What
sort
of
percentage
would
you
say?
Are
they
using
of
the
whole
stack
and
are
they
all
using
sort
of
a
common
part
of
the
stack
or
they
actually
all
use
any
kind
of
different
parts
like
that.
B
Right
so
I
would
like
to
mention
before
I
answer
your
question,
because
I
think
I
do
have
the
council
cycle,
so
I
do
want
to
say
that
it
is
different
to
ipfs
in
the
sense
than
the
p2p
is
a
library
that
is
normally
embedded
in
applications
with
the
expectation
that
that
library
will
allow
you
to
communicate
cross
communicate
with
other
applications
by
using
the
same
standards.
That
may
be
right,
so
this
essentially
means
that
Lippe
to
be
so.
B
If
we
go
and
modify
say,
for
example,
some
behavior
and
let
go
Olympics
being
because
we
are
the
main
contributors
to
build
a
p2p,
while
others
have
invested
in
significant
effort
and
built
on
Java
the
p2p,
and
we
end
up
breaking
the
compatibility
between
these
two
clients.
That
is
a
that
is
already
an
attack
on
the
principle
and
the
philosophy
on
the
p2p
right.
B
So
I,
guess
after
is
that
I'm
investing
in
the
p2p
want
to
be
sure
that
you
know
the
spec
work
and
the
direction
of
the
project
is
going
to
be
steered
in
the
right
direction
as
a
nose
forward
as
we
move
forward
together
right.
So
that
would
be
good.
That
would
be
kind
of
like
the
way
that
I'm
thinking
about
this
problem
statement
so
to
speak.
B
So
we
know
which
ones
they
are
we've
listed
them
and
people
are
that
is
kind
of
like
their
initials
and
every
product
for
that
right
after
that
becomes
the
question
of
how
do
we
maintain
and
continue
evolving
those
implementations
right
because
the
let's
say
the
the
goal,
the
immediate
goal
for
these
people,
who
have
an
immediate
interest
and
building
in
the
p2p
implementation,
is
already
satisfied
right
and
in
one
level,
which
is
being
able
to
speak
with
other
implementers
of
them.
Now
there
are
Libby.
B
Tp
is
gonna,
continue,
evolving
new
high
level
protocols
and
gossiping
new
discovery
protocols
to
you,
DHT
approaches
and
so
on
are
gonna.
You
know,
keep
evolving.
So
how
do
we
keep
those
newly
created
implementations
on
par
with
everything
that
keeps
developing
in
the
community
right
and
especially,
how
do
we
keep
governing?
You
know
what
needs
to
be
done
where
to
make
sure
that,
ideally,
everything
needs
in
lockstep
right,
which
is
which
is
impossible,
but
ideally
you
really
want
to
bring
your
stuff
and
your
changes
in
a
way
that
you
can
community.
A
B
Actually,
I've
already
kind
of
done
this
work
and
it's
completely
disputable
by
by
anybody.
Alright
I
just
came
to
a
project
to
once
and
a
half
ago,
so
I'm
still
getting
some
ideas
form
in
my
head,
I'm
just
gonna
link
you
to
a
ticket
where
we
recently
discussed
this
4d
theorem
with
easier.
Just
give
me
a
second.
E
So
I've
a
couple
comments.
One
is
that
so
one
thing
that
you
want
to
think
about
as
a
first
step
towards
governance,
just
figuring
out
what
are
the
sort
of
hard
lines
in
the
scope
of
the
project,
so
one
of
the
things
that
it
is
not
going
to
do
and
what
are
the
things
that
are
currently
not
written
down
that
are
like
fundamental
to
the
way
the
project
works.
E
One
thing
that
you
see
is
that
when
a
lot
of
people
should
go
up
there,
using
not
the
entire
project,
they're
hiring
it
to
accomplish
a
particular
job
and
then
their
vision
of
the
project
and
because
they're
contributing
they
are
now
sort
of
like
a
part
of
the
future
vision
and
sort
of
understanding
the
vision
and
communicating
it
to
other
people.
It
narrows
in
on
just
that
subset
of
things
and
then,
when
they
have
ideas
to
solve
new
problems,
they
may
want
to
solve
those
in
the
direction
that
conflicts
with
the
rest
of
the
project.
E
And
if
you
haven't
articulated
that
really
well,
it's
very
hard
to
tell
them
why
that
shouldn't
make
it
in
or
why
that
shouldn't
be
integrated
in
the
project.
And
somebody
that's
one
thing
that
I
would
worry
about
because,
like
with
any
project
this
size,
like
I,
mean
it's
so
pluggable
and
like
the
peer-to-peer
networking
space
is
so
huge
as
like
a
concept
like
I'm
sure
that
there
are
like
design
decisions
that
have
been
made
that
have
not
been
articulated
outside
of
DiClemente
shion's
and
so
just
surfacing
those
and
making
sure
that
those
are
like.
E
Clearly
mapped
out
and
that
they're
they're
part
of
sort
of
any
governance
structure
in
the
future,
because
you
know,
since
you
have
multiple
language,
implementations,
you're,
gonna
and
inspects
around
stuff,
you're
gonna
have
to
say
things
like.
Ok,
you
know
here
is
a
staging
process,
for
when
we
think
things
are
sort
of
ready.
You
know
they
have
to
be
an
X
number
of
implementations
at
the
Lavoie.
E
E
A
I
agree
with
that.
We
actually
had
experience
with
this
at
docker,
where
there
were
features
we
wanted
to
implement,
and
then
people
like
me
would
be
like
oh
they're,
just
doing
it
for
their
own
benefit
and,
and
it
wasn't
that
wasn't
really
quite
true,
but
it
was
hard
to
win
people's
trust.
I
don't
know
so
anyone
have
some
experience
with
that.
Let
me
just
ask,
though,
do
you
the
question?
The
basic
question
you're
talking
about
it.
Michael
is
the
boundaries
of
the
project.
Do
you
feel
that
a
strong
spec?
A
It
would
be
good
enough
to
make
it
clear
what
the
boundaries
are
like
like
we
just
that
you
know
this
is
the
spec
and
you
have
to
submit
a
you
know
something
equivalent
to,
and
you
know,
II,
IP
and
aetherium
or
whatever
to
if
you
want
to
grow
the
spec.
But
it's
not
it's
like
the
Constitution,
like
what
anything
that
was
left
out
by
default,
like
the
power
is
delegated
to
the
States
or
what
you
know,
something
like
this
I.
E
Think
that
it
needs
to
be
in
language
that
is
surfaced
to
more
people
than
just
a
spec
right
like
like
the
like.
You
know,
like
the
say,
like
the
Python
process
for
improvement.
Like
has
a
bunch
of
these
constraints
in
it,
but
the
vast
majority
of
people
that
write
Python
and
have
an
idea
of
what
is
pythonic.
E
You
never
read
that
spec
and-
and
there
is
like
a
vision
of
what
it
should
be
in
and
out
of
the
project
that
that
proliferate
wider
than
just
that,
because
there
are
other
documents,
that
kind
of
try
to
try
to
tell
people
that,
and
you
need
something
similar.
You
know
like
these
are
the
boundaries
of
the
project
and
I
think
there's
some
other
sort
of
approaches
to
how
things
you
need
to
articulate
as
well,
and
also
I
mean
those
are
living
documents
that
change
over
time.
E
E
One
thing
that
I
find
kind
of
interesting
so
there's
like
all
these
different
language
implementations
coming
up
and
then
there's
this
really
pluggable
nature.
Is
there
right
now
everything
is
in
the
main
org
there's
not
like
a
bunch
of
sort
of
plugins
that
people
pull
in
that
are
actually
in
other
orgs
that
that
are
being
managed
elsewhere.
At
some
point
in,
like
the
lifecycle
of
this
ecosystem,
there
are
going
to
be
people
that
build
those
components
in
isolation
or
build
them
somewhere
else
like.
A
B
I,
don't
want
to
say
that
we
do
have
a
number
of
modules
that
are
still
in
for
jeromy's,
personal
github,
so
on
some
level
we
do
have
an
now
being
referred
to
from
actually
like
quarterly
b2b,
so
the
PCB
is
referring
to
you
know,
stuff
to
Jeremy
and
stuff
on
and
so
on.
So
in
theory,
this
has
already
happened
happening
on
some
level
right
materially
at
least
but
yeah
I
agree
that
we,
you
know,
do
wanna
so
I
think
we're
getting
back
to
what
actually
expect
is.
B
In
this
context,
we
haven't
defined
what
a
what
the
material
for
a
spec
is
right,
because
you
can
define
a
spec,
as
you
know,
the
different
interfaces
that
need
to
be
implemented,
but
in
reality
that's
not
going
to
work
because
in
the
code
in
each
language
is
kind
of
different
than
what
feels
you
know.
Natural
in
one
language
is
gonna,
be
it's
not
gonna
be
natural,
so
defining
you
know,
hot
interfaces
is
loving.
We
to
go
forward.
B
I
would
say
that
defining
you
know
observable
behavior,
right,
defining
RPC
messages
and
why
of
formats
and
so
long,
and
essentially,
what
needs
to
be
defined
for
one
implementation
of
from
one
implementation,
ultimately
to
being
one
language
to
be
able
to
interoperate
with
another
implementation.
This
is
like
the
stuff.
That's
in
the
middle
is
the
stuff
that,
in
my
view,
belongs
to
a
spec
and
as
well
as,
as
you
say,
the
modularity
skeleton
right,
so
the
scale
it
and
how
the
different
concepts
inside
the
Libby
to
be
stack.
What
the
responsibilities
are.
B
E
A
I
have
an
observation
along
these
lines.
This
was
something
that
someone
at
Def
Con
said
to
me
and
I
hadn't
thought
about
it
before,
but
let
p2p
doesn't
draw
a
strong
distinction
between
spec
in
the
sense
of
like
the
wire
protocol
and
like
interfaces
in
the
sense
of
like
how
you
program
against
it,
like
we
kind
of
mix
the
two
concepts
together
and
in
some
cases,
we're
very
clear
with
the
wire
protocol
in
some
cases,
were
like
clear
on
how
you
interface
with
it.
A
F
A
F
Some
things
like
the
switch
yeah.
You
know
this
one
there's
not
a
wire
protocol.
There's
no
protocol
for
this
form
right.
It's
just
a
way
of
reasoning,
about
connections
and
stuff.
The
actual
the
only
things
that
actually
have
wire
protocols
are
like
multi-stream
and
SEC
IO
and
like
our
multiplexers,
beyond
those
three
there's,
no
like
wire
protocols,
I
guess
identifying
ping
count,
but
like
that's
that's
where
they
only
like
wire
bytes
come
in.
We.
F
Those
agreements,
hyojung
notes,
yeah,
that
would
be
like
multi-stream
our
multiplexers,
any
one
of
our
transport
encryptions
are
like
sekai,
oh
and
then,
whatever
like
higher-level
protocols
were
making
in
which
is
like
the
protocols
written
on
lib
p2p.
But
we
kind
of
rely
on
them
so
like
a
ping
and
I
did
in
a
fight
or
that.
D
A
Here:
here's
a
here's,
a
question
intentionally
provocative,
like
suppose
that
the
Python
lead
p2p
implementers
decided
that
they
didn't
want
to
use
the
switch
swarm
abstractions
like
internally
in
their
library.
Would
we
consider
that
a
conforming
implementation
or
we'd
be
like
you
guys
have
gone
off
the
rails?
A
B
F
Know
they
you
could.
It
could
be
a
little
kid.
Okay,
if
you're
speaking
the
protocol
I,
don't
care
what
your
code
looks
like
right,
you're
communicating
with
a
lit
p2p
node
you
have
implemented.
Let
me
to
be
sure
it
doesn't
follow.
The
official
like
we
have
like
ap
is
that
we
like
for
people
to
reason
about
and
to
make
thinking
about,
that's
easier.
But
if
you
following
the
protocol
you're
implementing
it
right,
there's.
D
Make
a
distinction,
which
means
something
someone
implements
lit,
p2p
and
someone
they
can
interface
with
a
bit
of
me
like
there.
There
are
projects
that
we'll
just
talk
with
avidity
like
I'd,
actually
like
the
other
gob
control,
the
demon
from
like
very
lightweight
clients.
It
technically
talks
a
bit
of
P,
but
they
don't
implement
all
but
to
be.
B
Yeah
I
agree
with
you
Steven
and
in
fact,
aetherium
1.0
is
intending
to
create
a
bridge
that
is
able
to
speak
to
Limpy
to
be
nodes
without
actually
to
be
so.
This
you
know,
might
be
an
incarnation
of
what
you
say
and
yeah
I
agree
with
you.
I
think
I
think
the
b2b
itself,
if
you,
if
you,
can
sit
on
the
p2p
as
a
product
right
as
an
entity.
One
of
the
core
principles
is
the
modularity
and
and
and
this
and
the
concepts
that
we
have
produced
to
achieve
a
modularity.
B
A
That's
exactly
what
what
jeremy
just
said
is
he's
happy
to
the
phone
I
was
going
to
make
like.
Maybe
we
should
draw
a
distinction
between
a
clear
distinction
between
the
wire
protocols
and
our
abstractions,
and
then
let
people
you
know,
go
around
saying:
hey
we're
compatible
with
the
p2p
versus
people
who
are
actually
implementing.
Look
if
you
like.
Maybe
we
that's
the
distinction.
A
We
should
be
clear
about
it's
not
actually.
The
question
was
supposed
to
be
provocative
to
suss
out
like
what
we
think
about
this
there's,
no
one
that
I'm,
aware
of
who
actually
wants
to
implement
quote-unquote
implement
Lupita
Pete
without
the
same
internal
abstractions.
They
mostly
are
just
trying
to
follow
what
the
go
code
is
doing
as
far
as
far
as
I
can
tell
I.
E
See
I
think
like
a
good
way
to
think
about.
This
is
like
if
you,
if
you
had
like
a
badge
to
put
on
like
a
product
that
said,
whippy-tippy
compatible.
What
would
that
mean
to
the
consumers
my
product,
but
with
their
expectations
be,
and
they
wouldn't
be
about
the
implementation
right?
They
would
be
like
if
I
had
one
thing
that
I
bought
from
somebody
and
something
that
I've
bought
from
somebody
else
and
I
posted
p2p?
E
So
until
there's
such
a
point
at
which,
like
there
is,
there's
something
at
a
high
level
that
you
can
say,
okay,
there
are
people
that
are
building.
You
know
completely
different
projects
to
interoperate
with
each
other
be
able
to
p2p.
That's
when
you
would
want
to
get
start
to
get
really
particular
about
what
it
means
to
be
the
PC
compatible.
That.
G
Sleep
it'll
be
I,
don't
care
if
you
don't
give
us
one,
maybe
the
him
when
the
abstraction
is
not
very
fitting
for
a
buttons
example,
wouldn't
be
three
players:
oh
yeah,
our
designs
need
to
follow,
decided
Philippi.
Now,
that's
not
how
it
is
so
follow.
Whatever
design
you
know
like
for
designing
your
implementers,
let
them
do
what
feels
needed
for
the
language.
It's
okay
and
that's
long
as
we
gave
the
same
basic
components
in
the
loose
heads
and
they
were
interoperable
with
lived
to
be
them.
They
early
I.
D
Actually
I
agree,
but
my
is
more
long
lines
of
I,
so,
like
I,
don't
expect
all
the
few
sensations
do
follow
the
same
like
interfaces,
but
I
do
expect
them
to
be
pluggable
and
two
likes
for
mobile
transports
are
constantly
like
that,
and
I
could
see
implementations.
Is
it
like
to
work
a
single,
hard
cutter
transporting
a
single
hard
cutter
particle,
a
single
like
basically
a
bunch
of
hard
coated
things
for
thought,
really
lib
p2p?
It's
just
something
that
happens
to
use
the
wire
spec
to
do
one
very,
very
specific
thing:.
B
B
A
A
So
let
me
put
another
question:
should
we
try
to
have
a
governance
working
group,
or
should
we
plant
on
that
problem
like
like
ipfs
is
doing
and
just
you
know,
basically
the
point
that
molly
was
making
like
look
it's
open
source.
You
know
everything's
out
in
the
open
like
we,
you
know
we're
you
have
just
as
much
impose.
Anyone
else
is
that
is
that
a
fair
summary,
what
you're
saying
well
yeah
I,
don't
want
to
okay,
not
quite
I.
Think.
C
C
That
governance
could
take
from
the
like,
non-existent
to
superlightweight
like
enough
information
that
people
feel
like
they
have
recourse
and
and
some
and
enough
control
that
they
they
have
a
say
in
this
and
then
like
the
much
more
heavyweight
where
you
know
it's
gonna
be
hard.
It's
gonna
take
a
long
time
and
you're
trying
to
design
the
perfect
governance
model.
C
That's
gonna
work
for
the
project
for
many
many
many
years
to
come,
and
you
know
that's
where
you
get
into
like
people
spending
quarters
and
years
just
trying
to
design
an
effective
governance
model
with
the
entire
community
involved,
which
to
me
ends
up
in
kind
of
like
the
etherium,
like
everyone
bike
shed
egg
on
the
right
way
to
structure
ourselves,
world,
which
is
a
hard
problem,
and
so
everyone
has
an
opinion
and
so
I
would
say
having
nothing.
Probably
does
make
people
feel
a
little
uncomfortable
having
something
really
lightweight.
C
That
just
is
like
an
FAQ
of,
like
you
know:
hey
I'm,
building
my
own
X
like
what
does
that
look
like
what
does
that
mean
for
me,
hey
I'm,
trying
to
get
X
merged
in
like
what
does
that
process?
Look
like
what
is
my
recourse
if
people
are
not
merging
my
stuff
as
fast
as
I
want
them
to
like
breaks
down
a
couple
of
those
those
common
situations,
but
it's
not
like
what
I'm
classically
call
a
governance
model.
It's
just
making
people
feel
like
they
have
recourse.
E
Yeah
I
mean
Tim
always
point
like
whatever
government
model
that
you
create.
It
needs
to
be
mutable
and
the
people
that
are
participating
in
it
need
to
feel
like
they
have
enough
ownership
over
it
to
mutated
over
time,
because
it's
like
the
same
governance
model
is
not
going
to
work
five
years
from
now.
It's
what's
going
to
work
today.
Another
big
thing
you'll
want
to
separate
out
is
the
contribution
process
and
the
governance
model
are
connected,
but
are
not
the
same
thing
and
you
probably
want
to
have
a
lot
of
different
contribution
models.
E
The
contribution
model
for
specifications
is
going
to
be
very
different
than
code.
There
are
different
constraints
there.
You
actually
need
to
limit
the
amount
of
discussion
in
some
ways
like
specs
and
nodejs.
Don't
have
the
issues
turns
off
in
the
repo,
and
you
can
only
comment
on
pull
requests
for
this
exact
reason,
because
it's
just
it's
much
easier
to
comment
on
ideas
than
it
is
on
code.
So
you
just
get
like
an
explosion
of
kind
of
comments
that
lead
nowhere.
E
So,
there's
just
like
a
lot
of
changes
that
you
want
to
be
able
to
do
like
at
an
individual
repository
level
and
how
the
contribution
flow
works,
but
then
for
big
decisions
that
impact
multiple
repositories
or
the
projects
as
a
whole.
That
flows
in
out
of
all
of
those
repositories
into
a
governance
structure,
and
there
I
would
come
up
with
something
like
you
know,
quick
and
effective
and
focused
on.
E
C
That'll
kind
of
involve
defining
what
what
is
the
rule
like?
What
is
the
common
case
and
the
common
case
just
works
like
this
great,
when
there
are
exceptions
like
well,
it's
your
escalation
process
for
good.
This
is
an
exception.
We're
gonna
figure
out
like
a
fair
way
to
work
through
this.
Here
is
some
like
lightweight
process
that
we
may
update.
That
helps,
helps
these
exceptions.
Get
worked
through
in
a
fair
way
like
that
sounds
like
those
are
the
components
that
would
be
needed
in
order
to
implement
what
you're
suggesting
yeah.
E
E
The
reason
why
you
have
you
know
frequent
like
calls
to
just
do
to
make
these
decisions,
it's
just
to
unblock
people
to
get
like
all
this
stuff.
Moving
again,
it's
not
it's
not
so
you
can
lord
over
and
sort
of
keep
every
individual
contribution.
It's
just
to
unblock
people
that
are
stuck
because
nobody
agrees
yet.
A
Yeah,
so
he
says
that's
touching
on
a
different
issue,
which
is
frequent
calls
where
we
review
PRS
that
are
stuck.
We
talked
about
that
for
a
while,
we
haven't
done
it.
We
could
convert
I.
Think
we've
had
a
number
of
conversations
about
converting
our
bi-weekly
Lib
p2p
call
into
that
and
doing
the
Stephen
actually
proposes
iteration
of
this
earlier
this
week
that
we
convert
that
we
do
the
updates
each
other
kind
of
in
an
async
fashion,
which
is
how
do
V?
Does
it
and
I
like
that
style
a
lot?
A
C
A
question
to
the
group
and
just
what
are
the
pros
and
cons
of
calling
it
governance
versus
you
know,
calling
it
something
else
that
is
a
different
word
other
than
governance.
Like
you
know,
I'd.
Imagine
that
saying
something
like
this
is
this
is
the
governance
of
the
project
is
a
weighty
thing
that
people
it's
gonna,
get
a
lot
of
people
wanting
to
have
input
and
comment
on
it.
C
I'm
saying
like
you're
is
the
general
documentation
of
the
rules
or
like
the
way
in
which
we
do
stuff
is
much
less
weighty,
but
also
might
people
make
people
not
feel
like
you're
thinking
about
it
as
governance?
And
if
it's
the
same
thing,
then
maybe
that's
a
problem,
but
just
curious
what
other
people
think
on
my
topic?
Well,
yes,.
B
I
wanted
to
maybe
just
to
provide
a
framework
to
also
that
question
maybe
provide
the
background
as
to
how
the
topic,
how
the
discussion
of
maybe
we
need
governance,
or
maybe
we
need
to
think
of
it-
start
thinking
about
governance,
actually
sparked
and
we're
gonna
we're
seeing
new
work
streams
happening
at
different.
You
know
different
places
in
the
world
at
different
teams
that
speak
to
each
other
very
little
because
they
own
they
each
are
developing
their
own
plans
and
so
on
and
and
some
in
some
way
they
ask
they
review.
B
B
We
will
want
to
keep
track
on
actually
what
is
being
developed
where
so
that
you
know
everything
is
in
a
single
entry
point
for
people
intending
to
the
p2p,
and
for
that
we
need
a
way
for
people
to
communicate,
to
us
and
to
the
project
and
to
maybe
the
steering
committee
of
the
project
or
like
the
core
contributors
for
the
poor
maintenance
of
the
project.
I,
don't
know
what
figure
this
can
take
right.
B
B
Maybe
this
needs
to
be
a
process
that
everybody
in
the
community
participates
in
then
they
need
to
be
like
for
something
I,
don't
know
what
lip
e2p
is
yeah,
it's
like
what
we
call
it
B
to
B,
because
I
don't
think
we
have
like
a
conclusion
from
the
discussion
we
have,
but
maybe
once
we
settle
that,
but
especially
we
have
some
conformance
tests
right.
So
these
are
the
things
that
I'm
thinking
about
like
the
structure
in
general.
B
Now
we
know
that
we
have
outside
contributors
that
are
willing
to
really
implement
the
B
to
D,
which
is
you
know
just
today,
different
to
the
contributions
that
you
might
receive
in
ipfs,
which
are
not
like
completely
implementations
of
ipfs
in
a
different
language
right.
So
just
the
nature
of
the
contributions
are
different,
so
I
think
it's
also.
We
also
want
a
place
where
people
can
communicate
with
one
another
directly
and
share
experiences
as
well
and
cross
pollinate
as
different
teams
are
implementing.
You
know
as
a
species
different
challenges.
B
For
example,
we
had
this
with
a
pilot
with
BT
which
are
just
going
through
the
core
going
through
the
specs,
and
they
are
in
parallel,
see
like
narrating
how
the
stack
action
works
right
in
parallel
with
their
vision,
like
with
a
fresh
mission
with
a
fresh
mindset,
which
is
great
right.
We
need
a
place
where
we
can
share
that
right.
So
maybe
you
know
a
discussion
forum
or
I.
Don't
know
like
well.
This,
like
too
late,
is
something
that
is
definitely
like
part
2
of
the
discussion
right,
but
it's
like
part.
What
is
well.
E
Yeah
I
think
they're,
like
I,
wouldn't
call
it
a
governance
document
to
start
I
would
just
call
it
a
contributing
document
and
part
of
the
contribution
flow
is
that
it
flows
into
this
decision
engine
at
the
end
and
that
can
be
sort
of
like
the
last
little
bit
there.
I
will
also
say
that,
even
if
you
don't
call
it
governance,
so
in
the
background,
a
lot
of
foundations
right
now
want
Libby
to
go
into
their
foundation.
E
So
there's
there's
a
lot
of
talk
about
that
like
we
should
probably
have
a
separate
call
about
that
stuff,
but
if,
at
some
point
decide
to
go
into
a
foundation,
the
stronger
sort
of
written
down
governance
model
that
you
have
when
you
go
in
the
better.
It
means
that,
like
you,
don't
have
to
make
any
kind
of
compromises
or
substantial
changes
to
the
project
and
how
it
runs.
E
When
you
move
into
a
foundation
like
you,
you
and
in
fact
you
can
just
make
sure
that
they
guarantee
that
autonomy
when
they
bring
it
in,
whereas
like
if
you
show
up-
and
it's
just
like
a
bunch
of
people
at
a
company,
that's
sit
in
a
room
together
and
run
a
project
like
those
projects
get.
So
we
want
to
be
as
far
away
from
that
as
we
can
and
we're
pretty
far
away
from
it
already.
But
just
the
farther
away.
B
Yes,
I
would
say
the
thing
like
if
we
call
it
contribution
like
the
one
thing.
The
one
thing
that
confuses
me
about
that
term
is
that
I
normally
see
contribution
guidelines
in
the
context
of
the
single
red
book
right
of
a
single
codebase,
and
what
we're
trying
to
create
is
something
that
is
over
like
that
is
a
mob.
You
know
it's
meta
contribution,
sort
of
like
aspect
to
it,
so
I
don't
know
it,
and
it's
really
all
it's
reading
about
a
lining,
different
work
streams,
so
something
in
terms
of
alignment
like
Lisa.
E
Also,
what
you
can
do
is,
you
can
say,
like
okay,
you're
gonna
have
to
have
a
name
for
whatever
this
group
of
people
is
that
are
making
decisions
like
if
you
called
a
technical
committee
or
whatever.
So
you
create
a
repo
for
the
technical
community
committee
to
have
those
discussions,
and
then
you
have
the
contributing
document
there
and
that's
for
the
outlines.
What
the
process
is
I.
A
Just
wanted
so
I
just
want
to
raise
a
point
on
so
I
feel
like
rose
presenting
some
some
good
points
about
there's
no
clear
entry
point
to
the
project
like
and
we
need
one.
You
know
it's
some
other
like
ambiguities
about
like
how
do
we
get
people
aligned,
but
there's
a
I
guess
the
decentralized
part
of
my
heart
says.
Maybe
the
thing
we
need
to
align
on
is
is
literally
just
the
wire
protocols
and
then
just
let
like
let
people
run
free,
I'm
curious.
How
people
react
to
that?
A
F
Just
for
the
sake
of
making
documentation
easier
and
making
things
feel
more
like
coherent,
I,
don't
want
to
dictate
exactly
how
everybody
needs
to
write
their
code,
so
we're
on
a
scale
here
somewhere
between
everybody,
do
what
the
they
want
and
everybody
do
it
exactly.
This
way,
I
think
we
should
be
like
here
where
we're
like
okay,
this
is
these.
Are
the
components
like
we
have.
You
know
roughly
these
concepts
and
we
define
like
on
top
of
the
actual
wire
protocol.
F
We
should
also
define
some
of
the
algorithms
around,
like
you
know
how
dialing
works,
how
like
handling
of
streams
works
like
when,
like
the
connection
manager,
type
logic
should
be
probably
like
some
of
that
should
be
thought
of
as
a
spec
like
just
so
that
there's
some
consistency,
and
so
we
should
define
the
set
of
those
like
algorithms
that
are,
we
consider
part
of
the
spec
and
everything
else
we
should
say
this
is
just
an
implementation.
Detail
feel
free
to
do
it
this
way,
if
you
want,
but
this
is
like
optional.
B
Road
yeah,
so
to
exaggerate
what
Jeremy,
saying
and
I
think
this
like
into
illustrating?
We
don't
want
to
be
going
to
give
talks
and
conferences
about
how
violently
to
be
just
think
about
how
cool
it
be
to
be.
Does
things
about
how
JX
would
be
to
be?
Does
things
we
want
to
get
a?
Let
me
to
be
and
have
people
understand,
those
concepts
have
had
the
certainty
that
at
least
80%
of
what
they're
going
to
be
seeing
in
each
of
books.
Implementations
is
going
to
be.
B
Know
if
we
were
done
with
this
Mike
yeah,
so
in
terms
of
the
entry
point,
one
of
the
things
that
people
mention
is
that
it's
too
difficult
to
understand,
what's
going
on
and
go
the
p2p,
because
everything
is
captured
across
from
me,
so
many
issues
and
so
many
ripples.
So
one
thing
that
we
discussed
and
I've
seen
discussions
about
this,
but
some
people
have
agreed
it
is
killing
off
the
issue
trackers
in
each
individual
repository
and
centralizing
them
on
the
top
level.
B
Gonna
p2p,
when
the
classification
system
like,
for
example,
something
like
what
something
similar
to
what
humanities
uses,
which
is,
they
have
labels
for
each
area
of
the
system.
So
we
could
have
labels
or
area
connection
manager,
area
appear,
store,
area
whatever,
and
then
the
pull
requests
in
each
individual
record
and
the
commits
can
reference
the
ticket.
B
Sorry,
the
issue
on
going
to
be
to
be-
and
this
is
something
that
I
think
would
simplify
at
least
for
people
coming
into
the
community
understanding
everything
that's
going
on
and,
on
the
other
hand,
github
on
the
bright
side,
just
announced
a
a
feature
to
transfer
issues
between
repositories.
So
it
seems
like
perfect
I
know
if
you
wanted
to
do
this,
would
be
a
good
I,
don't
even
know
how
we
take
decisions
like
this.
A
So
wait
so
I'm
a
I'm,
a
big
plus
one
on
trying
to
centralize
the
issues
into
a
into
a
few
repos.
But
while
we're
on
this
subject,
can
we
also
broaden
it
to
the
question
of
like
go
mod,
and
should
we
like
the
reason
go
has
so
many
repos
as
far
as
I
can
understand,
is
because
at
the
time
it
was
built,
the
goal
would
be
to
be
I
mean
at
the
time
it
was
build,
go
didn't,
have
any
kind
of
module
system,
so
it
was
like
you
had
to
create
separate
repos
to
modularize
stuff.
C
F
Is
things
being
kind
of
bundled
has
already
bitten
us
with,
like
hearing
people
really
like?
Why?
What
is
this
pulling
all
this
code
in?
Well,
if
it
was
more
properly
modular
than
you
could
only
pull
in
exactly
the
thesis
that
you
absolutely
needed,
I,
don't
allow
you
some
better
selection
room,
yeah.
F
The
reason
that
we,
the
reason
that
we
don't
have
like
a
Monterey,
though,
is
it's
really
obnoxious
to
manage
that,
and
it's
really
obnoxious
to
like
pull
in
different
pieces
vendor
it
deal
with
like
all
this
different
interactions.
I,
don't
know
I
really
like
the
modular
approach.
It
also
allows.
It
also
makes
it
much
easier
for
people
to
like
build
things
that
are
able
to,
inter
up
and
like
plug
in
to
the
p2p
and
so
like.
F
If
we
build
it
all
into
one
repo,
we're
much
more
likely
to
make
decisions
that
prevent
that
sort
of
modularity
from
happening
like
we
could
just
depend
on
this,
you
know
depend
locally
on
this
and
depend
on
these
interfaces.
Are
the
struck
directly
be
like
yeah?
It's
good
enough,
we're
all
here.
It's
that's
past
fine.
A
F
A
A
No,
he
says
now
all
right.
Well,
anyway,
sorry
I
didn't
mean
to
sidetrack.
Roll
I
just
wanted
to
I
mean
I
still
think
we
have
issues
spread
across
a
lot
of
repos
and
right
now,
waffle
is
like
the
only
system.
We
have
that
kind
of
unites
all
these
issues,
but
it's
like
you
know
no
one
at
nobody
really
uses
it,
except
except
a
couple
of
us.
B
B
G
Know
what
that
guys,
I
mean
there
is
value
in
having
some
distribution
of
the
issues
I
mean
because
there
are
some
issues
that
are
very
specific
for
the
particular
rep
on
which
they
are.
There
is
just
lady
directly
the
product
price
I
mean
we,
we
can
kind
of
care.
You
know,
like
global
issues
should
only
be
to
people
I,
don't
think
we
should
blanket
for
be
Jesus
own,
not
like
only
between
two
rebels.
It's
just
going
to
be
no.
D
F
A
I'm,
actually,
a
big
hub
fan.
The
reason
we're
using
waffle
is
because
J's
let
p2p
was
already
using
it
and
when
I
came
in
there
seemed
to
be
kind
of
momentum
behind
it.
But
now
you
know
I
know
I've
been
here
for
a
while.
A
lot
of
new
people
have
joined
like
I
think
it's
reasonable
to
reevaluate
what
what
tools
were
using
I
didn't
want
to
start
like
a
holy
war.
B
Yeah
so
personally
separate
organization
of
issues
from
the
fact
that
that
organization
needs
to
be
materialized
in
each
Red
Bull
having
its
own
patient
tracker.
I
think
these
are
two
different
things.
There
are
many
ways
to
organize
issues
in,
and
essentially
this
is
the
way
that,
for
example,
can
be
needy
is
just
edits.
B
B
A
We've
reached
the
end
of
the
allotted
meeting
time,
so
maybe
we
should
maybe
we
should
call
it
I
hope
we
can
have
more
discussion
async
about
with
a
lot
of
these
different
threads
like
first
the
tooling
stuff.
Second,
where
should
the
issues
go?
And
then
you
know
governance
like
should
weave
and
do
some
quote:
unquote,
governance
and
so
what'd.
She
look
like
like
I
feel
like
we.
This
has
been
a
good
way
to
get
issues
on
the
table.
Hopefully
we
can
have
create
an
action
plan.
Anything.
Does
it
sound
like
a
good
yeah
yeah.