►
From YouTube: Browsers & Connectivity SIG: today, Q1, 2020+ - IPFS GUI and Browsers Weekly 2020-01-23
Description
About IPFS GUI and Browsers Weekly: https://github.com/ipfs/team-mgmt/issues/790
IPFS Mirror: https://ipfs.io/ipfs/bafybeigegltvzlzdqcc5x3hy6weaxoydv6oogwjbiph2q4ptzyrckt45am/
For more information on IPFS
- visit the project website: https://ipfs.io
- or follow IPFS on Twitter: https://twitter.com/IPFS
Sign up to get IPFS news, including releases, ecosystem updates, and community announcements in your inbox, each Tuesday: http://eepurl.com/gL2Pi5
B
Sure
so
you
know,
as
I
think
the
blog
post
is
coming
out
and
the
pr2,
the
the
repo
is
in
progress,
but
there's
a
little
switcheroos
in
how
we
structure
the
working
groups,
the
first
half
of
2020,
to
be
able
to
a
meet
some
of
the
longer-term
bills
that
we
have
as
a
as
a
project
and
how
this
affects
the
browsers
and
GUI
work
is
really
really
important.
We've
kind
of
decided
that
we've
had
a
long
long.
B
You
know
one
of
the
barriers
that
we've
had
in
this
browsers
group
is
that
connectivity
has
been
a
problem.
We
did
a
kind
of
review
in
November
of
a
part
of
the
browser
Easter
and
we
stuck
ranked
all
of
the
open
issues
and
all
of
the
needs
that
we
had
it
all
the
way
down
to
like,
like
full
native
browser
limitation.
B
It
really
could
have
like
both
blue
sky,
stuff
and
practical
stuff,
and
then
we,
then
we
went
through
each
item
and
and
and
I
analyzed
each
one
in
the
context
of
the
others
in
the
list
and
all
the
top
priority
is
outside
of
CID
v1
were
around
connectivity
for
on
solving
things.
Like
how
do
we,
how
do
we
get
to
a
world
where
we're
if
two
browsers
are
running,
they
both
have
some
level
of
ipfs
support.
B
If
that's
the
thing
that
is
well
this
year
and
also
when
it's
running
in
an
OGS
on
a
server
or
local
TV,
so
we
have
these
multiple
different,
at
least
four
different
operating
contexts
for
GOP
fests.
Each
one
has
different
connectivity
capabilities
and
also
challenges,
but
we
want
to
be
able
to
tell
you,
like
the
the
broadest
opportunity
from
a
deployment
standpoint
there
is.
It
is
I
think
that's
running
inside
HTTP
web
pages
for
now
so
making
the
most
of
the
connectivity
options.
We
have
there
things
like
expanding
thing
to
DHT
to
webparts.
B
You
see,
connections
and
things
like
that.
It's
really
really
important.
So
this
alignment
of
what
the
browser's
group
is
doing
and
what
the
limb
PP
group
is
doing
in
the
JSP
at
land
is
extremely
important
strategically
for
us
to
be
able
to
set
up
a
BFS
that
works
for
we're
developers
are
today
one
of
the
keys
that
differentiations
that
I
make
when
I
think
about
the
strategy
is
the
difference.
We
talk
a
lot
about
adoption,
I
kinda.
We.
B
How
do
we
increase
the
adoption
of
might
be
FS
that
we
get
more
people's
hands
I'm
gonna,
make
it
easier,
developer
workflows
it's
like
that,
but
a
distinction
that
I
want
to
make
is
is
that
adoption
is
really
predicated
upon
availability
upon
the
idea
that
that
ipfs
is
actually
there
to
be
about
it
and
for
I
confess
to
be
a
available
in
that
sense
than
that
distinction
for
web
developers.
We're
developing
right
traditional
web
sites
for
even
d
web
developers
who
are
developing
gaps
and
for
browser
vendors
who
are
considering
implementation
in
native
integration.
B
So
this
is
kind
of
thinking
around
how
I
look
at
the
prioritization
decisions
that
we
need
to
make
when
it
comes
to
browser
connectivity.
I'd
really
encourage
you
as
a
group
to
really
start
thinking
about
the
changes
in
terms
of
really
specific
deployment
channels,
where's
the
operating
context
of
of
ipfs
most
important,
and
what
connected
challenges
exist
in
that
operating
context.
B
If
it's
ipfs
running
gsfs
running
in
an
HTTP
web
page
HP
web
app,
it's
best
that
the
where
we're
gonna
get
the
most
bang
for
the
buck
in
terms
of
making
meeting
developers
needs
today
to
be
able
to
get
them
on
that
great
path
to
a
decentralized
web.
Then
we
should
be
prioritizing
the
connectivity
needs
of
operating
in
that
context,
as
opposed
to
say
no
js'
demons
or
I
profess
Jessica's
running
in
in
a
web
extension
context.
B
So
thinking
about
things
in
terms
of
operating
context
and
then
making
decisions
based
on
how
and
that
affects
the
availability
and
adoption
efforts
of
browser
as
a
whole
as
a
broader
deployment.
In
so
that's
kind
of
like
just
the
four
minute
summary
of
how
I've
been
thinking
about
these
things
and
really
it's
a
product
of
Lydell
and
I
having
these
meetings
and
talking
about
this
stuff.
A
A
very
good
summary
of
where
we
are
and
why
we
are
like
joining
forces
together
in
this,
like
overlap
between
ipfs
and
the
p2p
I,
think
it
may
be
useful
to
kind
of
like
understand
the
current
state
I'm,
not
sure
who
created
those
like
three
Alec
questions,
but
I
found
find
those
super
super
useful
way
of
looking
at
them.
Jacobs
like
if
you,
if
you
want
to
go
up
about
current
state
or
should
I
like
go
over
at
the
point,
I've
had
it
and
then
you
can
add
your
maybe
yeah.
A
This
video,
like
joining
the
community,
has
community
may
be
aware
of
that.
So
that
T,
like
the
highlights
of
the
current
stage
in
my
mind,
is
that,
like
the
entry
points
are
good
stuff
notes,
those
bootstrap
notes
are
listening
on
WebSockets
right
now,
I'm
pretty
sure
we
always
dial
the
same
bootstrap
node.
Every
time
our
Chesley
p2p
note
starts
and
that's
sort
of
like
the
first
thing
like,
maybe
not
like
personally,
but
often
like
when
I
had
like
discussions,
conferences
and
and
people
approaching
me
on
IRC
another
channel.
A
B
A
Like
notes
that
are
capable
of
WebSockets
or
other
transports
that
we
have
in
web
browser,
we
still
don't
like
store
them
and
reuse
them
later.
We,
if
you
like,
close
the
tab,
you
shut
down
J's
idea
first
process,
and
then
you
open
it
again.
Everything
starts
again,
so
that's
like
the
one
thing
kind
of
related
to
connectivity
because
like
if
we
like
persist
peers,
we
may
be
like
more
robust
against
like
censorship,
but
also
against
like
network
failures,
when
cells
of
our
bootstrap
nodes
or
something
this
configuration
happen,
you
don't
fail
to
boot.
A
Your
note
it
would
work
and
then
there's
a
problem
space
related
to
the
fact
that
we
don't
have
the
HT
in
in
Jas,
and
that
means
what
do
we
do
for
discovery
so
right
now.
Basically,
everyone
that's
using
clique,
Jess
idea
that
maybe
I
was
I
profess
that
everyone
using
this
idea.
Files
in
like
web
browser
context,
mainly
the
context
of
regular
web
pages.
They
you
either
use
our
default
or
around
their
own
WebSocket
server,
which
provides
both
like
discovery
but
also
like
relay,
and
then
we
got
this
delegated
routing
which
works.
A
But
it's
like
if
I'm,
like
I've
set
it
up
in
brave
but
brace,
is
a
special
context.
When
we
are
able
to
establish
TCP
connections
so
there
it
makes
sense.
The
problem
in
web
browser
context
is
even
if
we
like,
enable
delegated
routing
and
someone
Alec
runs
their
own
server.
For
that.
The
problem
is
like.
A
That
requires
establishing
clearly
TLS
certificate
and
that's
not
something
like
FS
or
J,
said,
if
I
suppose
out
of
the
box,
which
means
you
got
this
additional
configuration
overhead
into
setup
and
connection,
so
reverse
proxy
in
front
of
that
set
of
certificates
and
stuff
like
that,
and
also
like.
We
also
did
not
wire
all
the
config
options
in
go
HFS,
but
that's
like
a
minor
detail.
The
biggest
problem
is
this
configuration
overhead.
A
So
that's
why
I
like
delegated
to
things
like
it
works?
It
works
in
brave
right
now.
The
problem
is
like
what
what
announced
in
the
HD
like
how
useful
those
records
are,
and
then
there's
the
last
leg,
often
like
in
my
mind,
it's
like
WebRTC
or
like
the
fact
that
we
are
actually
not
using
it
today,
it's
disabled
by
default.
Historically,
it
was
like
just
crashing
browsers.
I
did
some
tests
later.
A
A
The
some
user
reports
about
like
different
numbers
of
connections,
different
use
cases
and
at
which
point
it
there
was
always
a
point
when
something
crashed
so
Weber.
This
is
the
current
implementation
of
our
web
RTC
transports,
mainly
like
WebRTC,
star
I,
believe
those
are
disabled.
By
default,
some
people
had
success,
I
believe
like
gosh.
What
was
the
name
of
the
video
streaming
service?
They
tweaked
I,
remembered
I,
think
they
forked
I
will
transport
the
tweaked
like
either
like
the
data
data
stream
like
chunk
size
or
something,
and
they
reported
some
success.
B
And
this
this
is
an
area
where
I
feel
like
it's.
The
crashing
is
that
the
problem-
necessarily
crashes
always
probably
browsers-
are
also
well
used
to
that,
and
they
want
to
know
more
when
things
are
crashing,
so
that
I
think
there's
two
things
here
that
are
really
important
is
one
identifying
the
right
configuration
that
doesn't
crash
like
if
we,
if
you
need
to
reduce
our
connection,
count
and
cap
it
at
a
non
crashing.
B
State
testable,
crossover
great,
but
the
other
half
of
that
is
actually
building
our
relationships
with
browser
vendors,
such
that
our
input
and
our
minimized
test
cases
are
into
their
product
development
cycle
and
the
engineering
decision
making.
So
we
can
start
to
affect
their
their
their
decisions
based
on
what
our
needs
are,
not
something
we
can
do.
A
Yep
yep
so
that's
like,
for
we
are
not
using
web
RTC
by
default,
but
there
are
like
options
just
to
quickly
close
up,
and
we
got
like
basically
with
like
WebRTC
requires
some
sort
of
a
signaling.
So
we
got
the
WebRTC
star,
which
is
using
WebSockets
WebSockets
for
signaling
and
after
you
exchange
those
session,
information
then
establish
peer-to-peer
or
there
is
like
variant,
WebRTC
direct,
both
for
go
and
Jas,
and
that
variant
is
using
HTTP,
just
like
regular
HTTP
endpoint
for
signaling
and
then
the
connection
established.
So
like
we
got
some
transport.
A
C
Yeah
no,
it's
that's
accurate,
however,
with
the
p2p
refactor
and
the
JSI
PFS
refactor
WebRTC
star
will
be
enabled
by
default
for
the
browser.
I
think
that
the
only
issue
there
is,
we
still
need
to
relaunch
some
web
RTC.
Star
servers
will
be
shutting
down
like
what
socket
star
is
going
away,
because
there
were
a
lot
of
issues
migrating
that
refactoring
that
because
of
socket
IO,
but
we
didn't
have
to
do
those
things
for
whatever
TC
star.
C
So
it's
going
to
take
the
place
of
web
sockets
are
so
we'll
be
looking
at
taking
some
of
the
web
sockets
to
our
servers
that
we
host
and
then
changing
those
over
to
WebRTC
star.
So
we
will
have
that
and
then
yeah.
That's
that's
a
good
rundown
of
the
current
state
and
a
lot
of
the
things
you
went
over
are
things
that
I
have
listed
solutions
in
my
backlog
for
that
I
want
to
tackle
this
year.
So
that
is
as
good
I.
A
Really
like
the
idea
of
like
I,
think
I
put
a
question
mark
about
like
look,
improving
star
situation
and
I
feel
what
you
just
said
like
switching
to
WebRTC.
It
will
like
make
stuff
better,
given
that
we
would
no
longer
push
bytes
through
that,
like
real
life,
like
all
the
bytes,
we
would
just
like
use
that
for
signaling.
So
that's
like
a
step
in
the
right
direction.
A
What
are
the
like?
The
major
issues,
either
the
p2p
or
ipfs
users
face
today
in
our
browser
context,
I,
like
I,
listed
lack
of
HD,
which
I
mentioned
before
the
another
common
problem
on
forums
etc.
So
and
going
over
and
over
was
like
a
lot
of
stuff
requires
manual
configuration
like
hard
coding,
specific
servers.
That
also
implies
like
semi
centralization,
which
means
you
either
use
like
most
of
people
when
they
start
playing
we'll
use
the
default,
bootstrap
servers
or
WebSockets
our
servers,
which
are
listed
like
just
for
demos.
A
Everyone
is
using
them
and
it's
like
either
like
optical
documentation
or
too
many
steps
like
too
many
services
to
setup
like
bootstrap
servers,
WebSocket,
stars,
preload
and
then
delegate.
Those
are
like
four
things
which
probably
could
be
just
one
thing,
and
then
in
this
is
specific
to
JSI.
Dfs
is
the
problem
of
data
preload,
it's
sort
of
like
a
like
in
the
p2p.
We
got
the
doors
like
delegated
through
things
so
like
data
preload
is
like
delegating
caching
of
the
data
you
just
added
to
your
local
J's
at
the
first
node.
A
If
you
get
it
enough
time
that
data
it's
still
available
to
other
peers,
because
it's
cached
in
on
that,
like
remote
node
data
preload,
it's
like
specific
feature
of
GSI
DFS,
it's
not
in
go
it's
just
like
in
J's
idea
first
and
was
added
specifically
for
this
browser
context
and
basically
I
always
think
we
will
collapse
even
like
a
partial
solution
to
this.
Like
too
many
things
to
configure,
we
will
probably
collapse
a
delegate,
nodes
and
preload
nodes.
A
Those
will
be
like
wanting
we'll,
probably
just
call
them
delegate,
because
we
haddock
with
keep
adding
stuff,
and
we
probably
should
click
start.
Managing
them
together,
take
up
the
fear
from
the
likely
p2p
site,
or
maybe
some
of
your
users
other,
like
any
other,
like
pain
points,
we
did
not
leave
you
yeah.
C
I
think
you
touched
on
like
one
of
the
biggest
pain
points.
I
think
with
Libby
to
be
is
really
like.
The
manual
configuration
like
configuring,
we
bidipi
is
painful
for
people
with
a
refactor
we've
like
added
a
configuration
guide,
but
I
still
think
for
most
people.
That's
that's
a
large
overhead,
so
I
think
something
that
we
may
look
at.
Trying
to
do
this
year
is
actually
like.
C
We
have
in
GSI
BFS
we've
got
like
the
you
know,
runtime
files,
and
these
are
like
the
pre-configured
things,
but
then
there's
like
JSF
EFS
has
like
a
bunch
of
different
because
it's
run
in
so
many
contexts.
It
has
like
multiple
ways
to
configure
Lib
p2p
and
it's
like
a
nightmare
to
look
at
but
I
think
going
through
from
a
little
peepee
standpoint.
We
can
at
least
hey
here
are
like
pre,
bundled
the
p2p
like
based
on.
C
B
There
is
not
a
decentralized
option
for
people
at
all.
Today,
in
web
browsers
period,
like
the
gate,
the
initial
step,
there
is
always
going
to
be
centralized.
So
how
can
we
take
advantage
of
that
centralization
and
use
it
as
a
wedge
to
get
in
there?
I
think
is
exactly
the
right,
the
right
approach
and
the
way
to
think
about
it
and
having
a
embed,
a
language
like
the
way
you
just
described
it.
B
Jacob
I
think
is
really
helpful
for
understanding
how
we
make
those
decisions
and
be
able
to
talk
about
wyck,
that
spectrum
of
said
the
thing
about
centralized
and
essentially
as
a
spectrum,
not
as
a
binary
so
and
I'm
totally,
plus
one
on
thinking
about
things
that
way
and
really
centering.
This
idea
of
bundles
is
being
very
user
centered
and
how
we
understand
what
developer
needs
are,
which
is
plus
one
on
that
too.
A
A
Just
like
I
mentioned,
we
probably
the
low
hanging
fruit
is
like
at
least
saving
for
later
use.
All
the
peers
we've
discovered
it.
Maybe,
and
probably
we
should
also
like
it
might
be
like
generic
thing
for
the
p2p,
but
like
like
tracking
peers,
who
are
like
always
available
like
over,
like
days
or
like
for
sometime
and
assigning
some
wage
to
them.
A
The
the
problem
is
like
to
sunset
stuff.
We
would
have
to
have
like
existing
solution
that
replaces
it
and
that's
working
progress.
That's
my
understanding!
So
I,
just
copied
roadmap
I
extracted
the
road
map
from
the
issue
here.
But
basically,
my
understanding
of
the
high-level
plan
for
sunset
excel
protocols,
is
that,
like
we
got,
the
random
OOP
like
protocol
specs
out
I,
think
we
got
like
initial
implementation,
but
it's
not
actually
like
that
test
that
our
users
used.
So
probably
that's
literally.
A
A
C
C
As
then,
I
can
then
exchange
with
the
peer
I
connect
to
I
can
exchange
the
peers
that
I
have
with
them
so
that
they
can
then
get
a
list
to
like
hydrate
their
peer
store
and
then
persist
that
and
then,
when
they
come
online
and
reconnect.
Somebody
else
right.
We
can
just
continue
to
just
share
those
peers
you're
on
so
I.
Think.
A
A
I
think
we
just
need
to
ensure
stuff
does
not
break
when,
like
a
single
signaling
server
goes
away
and
clearly
document.
What
are
the
options,
what
are
trade-offs
and
what
I
like
and
emphasize
that
you
can
like
use
multiple
ways
like
multiple
discovery.
All
the
like,
the
modularity
of
both
like
J's
ipfs
ability
to
be
I
feel
is
often
like
skipped.
Our
not
present
in
in
Docs
and
people
are
not
aware
that
it's
not
like
they
need
to
choose.
They
can
back
just
multiple
discovery,
matters
and
stuff
like
that.
A
So
I
I
had
a
section
with
like
question
marks
regarding
like
improving
star
situation
before
sunset,
engage
so
I
feel,
like
you
mentioned,
the
web
RTC
like
switching
to
web
RTC
as
a
default
like
in
the
default.
Configuration
would
be
like
part
of
that
and
there's
a
separate
topic
of
replacing
WebSocket
star
with
this
new
Stardust
protocol.
The
problem
is
like
a
new
protocol.
A
C
It
was
running
ingest,
ipfs,
I
believe
in
check,
or
at
least
a
preliminary
version
of
it.
The
advantage
is
like
we
don't
have
to
like
leverage
socket
IO
and
it
does
kind
of
like
a
pure
data
exchange.
So
it
is
an
option
for
like
replacing
WebSocket
star,
at
least
in
the
interim,
because
web
sockets
are
was
like.
The
socket
IO
stuff
is
just
a
nightmare
to
refactor
back
but
I
think
it's
it's
one
of
those
things.
C
It's
like
a
stopgap
right
of
like
until
we
get
like
the
rendezvous
server
chilly,
get
like
WebRTC
distributed
signaling
over
relays.
Things
like
that,
where
any
node
could
be
a
a
signaling
server
that
like
we
should
have
some
stop
yep
in
place,
and
so
that
was
like
hey.
If
we
get
started
in
place,
that's
another
option
that
people
can
use
I'm
in
addition
to
WebRTC
star
until
we
get
these
other
things
so
nourished.
A
Yeah,
it
sounds
viable
I
was
like
looking.
What
would
need
to
happen
on
our
like
infracells
want
to
make
a
switch
and
acting
like
this,
which
you
mentioned
that,
like
switching
the
default
on
the
bundle
distribution
to
like
WebRTC
star
at
the
same
time,
we
could
but
move
the
WebSocket
styles
button,
switch
like
either
documentation
or
yeah.
Probably
if
we
no
longer
like
Ranas
startup
by
default,
like
switch
the
documentation
and
point
to
startup.
The
thing
is
that
I
start
does
require
separate
set
of
servers.
A
C
So
we
have
a
purchasing
star,
it
needs
to
be
redeployed,
it's
like
I,
pretty
sure
it's
like
500
shooting
right
now.
So
we
need
to
improve
our
infrared
at
soon
like
in
the
next
weeks,
and
then
we
have
so
we
have
one
WebRTC
star
server.
We
actually
have
three
WebSocket
star
servers,
but
we
only
ever
point
to
one
right
now.
C
So
one
of
the
thoughts
is
to
like
leverage
the
other
two
that
we're
not
pointing
at
and
then
also
move
those
over
to
WebRTC
and
then
have
three
running
right
because,
like
we
do
have
historical
issues
of
only
being
able
to
open
so
many
whoever
CC
star.
So
if
we
can
get
like
hey,
we
have
three
servers
that
are
running
then
we
can
also
make
sure
that
if
one
of
them
goes
down
that
we
still
have
the
other
two
until
we
can
get
them
all
back
online
yep.
A
That's
something
we
like.
Without
this,
everyone
will
be
using
the
default
ones,
and
it's
probably
better
for
everyone.
If
we
improve
this
I
talked
with
Steven
about
the
idea
of
adding
support
for
TLS
to
go
ipfs,
but
specifically
not
for
HTTP
gateway,
because
that's
like
a
kind
of
forms
we
don't
want
to
open
yet,
but
just
for
just
for
WebSockets
see
if
we
like.
C
Yeah
I
think
should
go.
There's
a
team.
That's
been
trying
to
work
on
like
they
need
this
because
they're
like
they're,
taking
gold,
let
p2p
and
they're
compiling
it
to
webassembly
and
then
using
basically
that
same
thing
of
like
communicating
over
WebSockets
but
they're
having
the
problem
this.
This
exact
problem
of
the
WebSocket
transport
in
Golub
btp
doesn't
support
WSS
and
so
in
they're
having
a
problem
that
they
originally
wanted
it
to
be
decentralized.
C
A
A
Yeah
I
feel
like
it's
probably
like
the
probably
realistic
way
of
tackling
those
issues,
would
be
be
more
pragmatic
than
just
like
going
at
foot
full
force
with
some
settings
style
protocols,
because
that
may
take
time
so
like
what
would
be
the
first
stage.
We
would
if
we
have
like
the
first
milestone.
That
would
be
probably
after,
like
there
factors
are
done,
switching
route
to
web
RTC
star
right
as
the
default.
That
would
be
the
first
thing
for
this
year.
Yeah.
C
A
Yeah
I'm
not
sure
if
I'm
not
like
saying
garbage
right
now,
but
I,
don't
think
we
have
access
to
web
RTC
API
from
whoop
service
workers
or
do
it
I,
don't
think
we
do
I'm,
not
sure
so
assuming
I'm
right.
We
would
still
like
that.
A
Switching
to
start
that
probably
would
be
necessary
anyway,
because
if
someone
wants
to
run
like
Jess
ipfs
in
Service
Worker,
if
there
are
like
brief
enough,
they
would
not
be
able
to
use
the
web
RTC,
and
that
means
they
would
need
like
WebSocket
based
one,
because
you
keep,
you
can
establish
WebSockets,
WebSocket
connection
but
I'm
pretty
sure
I
remember
there
were
maybe
not
all
browser
vendors,
but
it
was
not
Universal
either
Firefox
or
Chrome
did
not
allow
for
web
web
RTC.
I.
Think
there
is
this
like
open
ticket.
A
I
did
was
chromium
about
like
allowing
data
channel
connections
from
serviceworker
could
not
when
service
workers
was
created.
The
web
RTC
was
only
used
for
audio
video,
so
it
was
like
I.
That
does
not
make
sense.
So,
let's
just
block
it,
and
now
we
don't
have
access
to
web
RTC
I
believe
in
some
vendors.
Sorry
for
digression
just
like.
A
B
C
D
A
You
probably
like
get
us
to
the
point
where
we
you,
you
may
need
to
like
enable
some
flags,
but
you
don't
need
to
like
be
installer
anything
additional
to
remove
like
the
friction
and
like
cognitive
overhead
for
people
who
want
to
like
round
around
inside.
Otherwise,
people
will
just
say:
alright.
I
don't
have
time
for
like
reading
this.
Setting
this
up
I
would
just
use
those
default
unless
they
break
then
I
would
start
reading
this
so
yeah,
okay,
okay,
can.
B
You
so
everyone
asked
for
this
work.
Can
you
can
you
summarize
that
that
outcome,
so
where
we're
gonna
be
where
you
want
like
the
target
you
want
to
hit
at
the
end
of
the
quarter,
so
we
have
an
understanding
kind
of
what
the
what
the
objective
is
from
a
developer
experience
template
for
people
that
are
wanting
to
use
Jess
ipfs
in
this
context,
what
it
was
changed
is
the
goal
going
to
be.
B
For
example,
this
is
zero
config
is
the
goal
going
to
be
better
connectivity
with
the
existing
config,
but
just
it's
summary
to
be
able
to
understand
where
we're
getting
at
in
this.
In
this
broader
context,
for
this
quarters
work
that
we
can
use
as
the
OKR
for
the
browsers
and
connectivity
work,
the
ecosystem
group
would
be
super
helpful.
We
want
to
definitely
before
team
week
have
that
lockdown,
oh
yeah,.
A
Yeah
III
can
flesh
it
out.
Basically,
I
need
to,
like
think
about,
like
the
call
like
the
current
scope.
What
people
need
to
do
like
go
ipfs
and
then
nginx
and
what
they
need
to
set
up
in
nginx
and
see
what
we
are
liquid-liquid
realistically
can
like
move
to
go
idea.
First,
configuration
wise,
yep
totally
some
time
in
gateways
corner,
maybe.
A
Let's,
let's,
let's
do
this
alright,
so
it's
very
quick
I!
We
can
go
developer
this
week
and
picked
up.
Tr
we
subdomain
gateways
and
the
thing
I
wanted
to
get
to
work
was
basically
like
the
Gateway
on
localhost
and
I,
got
it
to
the
point
where
I
was
able
to
like
load
Wikipedia
from
like
that
IDF
at
localhost
domain.
A
So
CID
is
in
the
main
it
loads
and
all
the
paths.
The
Wikipedia
is
a
very
good
test
case.
Cuz
there's
like
assets,
relative
paths
shut
the
directory.
So
if
anything
breaks
it
will
break
on
Wikipedia
and
cool
stuff.
Is
that
like
we
not
only
got
those
Lexi
IDs,
we
also
got
like
IP
NS
namespace
and
it
works
the
same
as
IP
NS
path
namespace.
So
if
someone
puts
domain
name
here,
we
will
resolve
the
Annette
link
and
load
content
addressing
path
from
that
path.
A
A
Same
ways
like
our
dog's
website
and
what's
cool,
is
that
the
existing
integration
with
DNS
guys
also
works
with
this.
So
we
got
those
eth
domains,
loading
from
localhost
gateway,
which
is
pretty
pretty
critical,
so
those
goods
will
land
at
some
point
you'll
to
figured
out
some
some
things
around.
The
configuration
I
want
to
like
add
some
keys,
which
are
not
there,
trying
to
add
them
and
wire
down
them
up
and
also.
A
Need
to
select
summary
factors
to
like
shuffle
stuff
around
cause
like
in
someone.
If
someone
is
running
the
DNS
link
website
and
a
gateway
on
the
same
domain
name,
we
want
to
prioritize
content
paths,
probably
just
just
to
like
remove
at
edge
cases.
So
a
good
example
is
like
I
TFSI.
Oh,
it's
a
path
based
gateway,
but
also
a
regular
website
which
is
backed
by
DNS
link.
So
what
happens
is
that
the
NSF
website
has
like
ipfs
subdirectory?
A
B
A
B
A
A
B
So
one
of
the
things
that
just
came
up-
we've
talked
a
lot
about
like
goals
that
we
have
when
we
want
to
get
to.
With
with
brave
for
context.
We
still
have
an
incoming
grant
application
where
Ranger
Bob
will
be
working
on
brave
to
brave,
DNS,
St
local
discovery,
so
we
can
actually
start
working
on
for
to
Braves
with
embedded
nodes
on
the
same
local
subnet
they'll
be
able
to
interoperate
music.
B
He
must
communicate
directly,
even
if
they're
not
connecting
the
internet
super
powerful
demonstration
of
just
how
important
actually
having
full
node
native
immigration
in
the
browser
as
and
and
hopefully
that'll
start
to
happen
this
quarter.
But
the
activist
grant
situation
is
still
still
evolving
and
just
really
getting
started.
So
we're
working
our
way
through
that,
but
there's
a
couple
of
other
major
bits
that
we've
talked
about
for
brave
support,
and
this
came
up
in
a
conversation.
But
it's
really
nice,
it's
so
nice
that
Brendan
is
so
active
on
Twitter
and
retweet
stuff.
B
All
the
time
like
when
you
talk
about
the
things
that
you
want
to,
do
that
maybe
you're
not
sure
if
you
can
yet
so
I
didn't
commit
our
roadmap.
Publicly
I
did
talk
about
some
things
that
we
know
we
want
to
do
so.
There's
a
few
things
there
like,
like,
like
emptiness
implementation,
I,
think
that
the
brave
community
is
really
tolerant
of
hard
experimenting,
hard
and
deep
in
in
this
area,
and
it's
really
something
that
we
should
be.
B
We
should
take
advantage
of
as
much
as
possible,
so
the
fact
that
we
can
actually
get
a
local.
You
know
node,
that's
in
browser,
because
any
external
daemon
to
be
installed,
no
I
professed
required
and
understanding
kind
of
the
limits
of
what
we
can
do
in
that
space.
From
an
experimentation
standpoint
I
think
it's
gonna
be
really
powerful
and
can
really
galvanize
that
community
around
thinking
about
more
thinking
more
broadly
about
what
they
can
do
when
things
like
ipfs
are
actually
just
running
locally
available
in
some
form
to
web
applications.
B
I
think
also
that's
a
place
where
we
have
an
opportunity
to
explore
native
protocol
handler
and
desktop
experiences.
So
in
the
Opera
implementation
is
going
to
give
us
a
native
protocol
handler,
but
a
behind-the-scenes,
HTTP
gateway
experience,
and
here
we
have
the
opportunity
to
be
able
to
have
knit.
We
need
a
protocol
handler
combined
with
the
local
node
and
that's
something
that
we
have.
We
still
have
to
figure
out
standard,
but
we
have
to
figure
out
things
like
you
know.
What
is
the
actual
capability
capability?
B
You
know
what
garden
they're
walled
garden,
whatever
we
want
to
put
walls
from
a
security
model
standpoint.
How
does
that
security
model
align
with
the
existing
HP
security
model?
Doing
things
to
say
like
if
something's
loaded
in
the
in
the
ipfs
near
to
protocol?
Do
we
just
like
from
the
from
the
start?
It
just
be
like
turn
off
all
cookies,
yes
or
no
like
we
have
the
opportunity
to
be
able
to
dictate
how
this
security
model
works
and
I.
B
What
we
want
for
for
for
a
brave
and
as
an
exemplar
of
browser
and
integrations
for
this
year,
but
I
think
really
the
end
goal
for
the
year.
What
I
would
like
to
see
is
us
having
a
really
solid
understanding
of
those
three
things.
What
the
with
a
security
model
Fred
for
some
browsers
is
with
a
privacy
model
for
I
profess,
some
browsers
is
and
then
with
it.
What
does
things
mean
in
the
context
of
an
application
model?
You
know
the
web
application
model.
Is
this
HTTP?
B
What
delivering
assets
that
are
ultimately
rendered
like
HTML
and
JavaScript
and
CSS?
That's
the
application
model
is
the
combination
of
that
network
transport.
The
key
features
the
capabilities
of
the
network
transport
combined
with
this
rendering
context.
This
is
what
features
does
the
browser
give
to
the
JavaScript,
that's
actually
being
executed?
What
does
it
let
it
do
what
it
wears
to
have
dependencies
on
user
interaction,
which
is
a
really
key
part
of
evaluating
feature
capabilities
in
the
context
of
the
security
model?
A
And
it's
like
the
native
protocol.
It
just
sounds
easy,
but
we
flip
the
web,
which
we
experimented
in
2018
a
with
Mozilla
we've
identified
there,
like
so
many
unknown
like
now.
Those
are
known
unknowns
but
like
there's,
no
spec
about
like
cross
protocol
requests
or
like
J's
execution.
Absolutely
not
it's
like
Wild
West,
no
one
has
know
an
idea,
and
it's
interesting
cause.
It's
like
repeat
like
history,
repeating
itself
when
HTTP
was
added.
Similar
questions
were
raised
like
how
cross
protocol
requests
should
work.
A
B
Yeah,
like
a
lot
a
lot
of
the
threats,
a
lot
of
the
threats
in
the
existing
model
are
pushed
actually
out
a
layer
down
into
network
network
transport
concerns.
So
it's
actually
like
it
almost
more
tightly
couples
to
security
privacy
models
with
the
network
transport
layer,
as
opposed
to
the
application
love
there.
Yep.