►
From YouTube: E2E testing plan for WebUI, news from Chrome Dev Summit - IPFS GUI and Browsers Weekly, 2019-11-13
Description
About IPFS GUI and Browsers Weekly: https://github.com/ipfs/team-mgmt/issues/790
IPFS Mirror: https://ipfs.io/ipfs/bafybeievfynl2iran32hjxaiidvkvj6kziyylak25rc42autiamecbisui/
A
B
A
A
So
we
would
like
to
test
where
do
I
like,
let's
say
the
basic
test
case
that
we
want
is
adding
files
and
directories
to
ipfs
using
web
UI
interface,
and
we
would
like
to
ensure
that
core
functionality
does
not
break
in
chromium,
Firefox
and
electron
electrons
on
the
list,
because
ipfs
desktop
is
based
on
electron
and
we
render
web.
You
are
using
electron,
renderer
process
right
now,
IP
first
desktop
runs,
you
go,
IGFs
butts
like
people
may
run
webui
against,
go
or
Jase
ipfs
in
companion
or
on
their
own.
A
A
What's
between
where
we
are
right
now
and
this
perfect
world,
when
we
have
this
test
matrix
and
my
initial
idea
was:
oh
yeah,
we
will
just
add
edger
edge.
It
has
a
built-in
support
for
running
against
those
runtimes,
so
the
run
against
chromium
Firefox
and
an
electron
renderer
and
we're
golden.
So
the
problem
is
so
like
I
think
a
jury
is
not
the
problem.
A
The
node
modules
is
already
one
gigabyte
in
size
and
then,
if
you
add
a
juror,
it's
like
twenty
eight,
two
hundred
megabytes
more
so
it's
like
in
the
past
I
believe
the
difference
mark
was
much
bigger
and
I.
Remember
the
discussion.
When
we've
been
talking
about
adding
edger.
Oh
it
will
make
the
node
modules
too
big,
but
right
now
it's
relatively
to
the
current
stay
size
of
node
modules.
It's
not
a
big
big
problem.
A
The
problem
is
that
edger
itself
is
at
all
focused
on
mostly
to
improve
our
velocity
around
developing
libraries,
and
that
means
it's
very
opinionated
around
that
it
expects
tests
to
be
written
in
mocha
and
we
run
those
tests
using
karma
in
different
environment.
So
we
are,
we
can
run
in
node,
but
then
we
use
karma
to
run
in
Firefox,
Chrome
and
electron.
A
We
use
that
also
to
run
in
work
web
worker
environment.
So
we
we
have
separate
tests
for
libraries
to
how
a
library
works
in
regular
webpage
when
there's
like
a
window
object
and
then
in
serviceworker,
when
there's
like
just
like
self
stuff
like
that
and
that's
edger,
the
problem
is
in
web
UI.
We
don't
use
edger,
we
use
just
for
tests
and
we
have
proof
of
concept
for
running
puppeteer,
for
running
end-to-end
tests
with
puppeteer
and
that's
sort
of
the
same
semi
manual
process.
So
that's
the
first
problem.
A
A
How
would
it
look
like
if
we
refactor
test
from
just
mocha
and
then
turns
out
most
of
people
move
in
opposite
direction
from
Wacha
to
Jess?
So
we
not
only
don't
have
any
community
to
link
that
would
help
us
in
like
transforming
code
or
mapping.
It
would
be
like
the
cost
of
refactoring
could
be
kinda
big
and
then,
even
if
we
switch
to
that,
like
karma
itself,
does
not
solve
the
end-to-end
tests
at
the
level
we
need.
So
we
we
sort
of
need
this
green
reality
of
puppeteer
cause
like
karma
itself.
A
It
just
runs
those
like
unit
tests
in
a
web
web
browser
context,
but
what
we
want.
We
need
a
puppeteer
to
like
orchestrate
browser,
to
go
to
specific
URL
to
actually
click
on
specific
object
and
those
days
like
historically,
there
were
selenium,
but
I
am
pretty
sure
we
we
don't
want
to
go
that
route
and
puppeteer.
Those
days
may
be.
A
So
that's
like
a
20x
or
so
and
I
feel
we
probably
don't.
We
are
not
very
controversial
by
sort
of
adding
puppeteer
as
a
hard
requirement
for
what
we
need
for
this
project.
So
long
story
short
from
this.
From
from
the
current
point,
we
can
either
move
to
like
mocha
and
karma,
but
the
problem
is
that
does
not
solve
the
problem
that
we
need
to
still
add
support
like
puppeteer,
so
we
will
either
need
to
run
puppeteer
somehow
from
a
karma
or
at
a
specific
runner
or
something.
A
Basically,
this
sounds
like
extending
agile
at
some
point,
because
we
don't
want
to
like
add
additional
layer.
It
feels
like
something
closer
to
edger.
So
then
we
could
just
say:
okay,
edger
actually
does
not
help
us
with
tests.
Let's
stay
with
just,
and
maybe
we
should
simply
improve
our
puppeteer
setup.
So
right
now
it
just
runs
puppeteer.
A
So
that
means
we
just
test
against
Chrome
chromium
and
it's
like
semi
manual,
but
there
are
like
tools
for
both
improving
orchestration
and
improving,
gives
us
like
the
DSL
for
writing
tests
against
puppeteer
without
like
using
those
low-level
API
so
directly.
So
there's
like
just
puppeteer
project
I
found,
which
sort
of
like
bridges
this
gap
between,
just
which
we
already
use
and
in
the
same
style
we
could
write
and
plan
tests
and
I
started
scratching
this
on
local
branch.
But
then
this
call
happens,
so
it
may
be
something
who
I
will
pick.
A
Maybe
maybe
Enrique
will
be
interested
in
like
seeing
if
it's
a
way
to
go.
But
basically,
if
we
go
in
in
this
direction,
we
don't
need
to
touch
existing
tests
like
unit
tests.
Just
that
this
would
stay.
The
only
thing
we
would
improve
is
this
end-to-end
setup
which
we
already
have,
but
over
basic
form.
A
We
would
just
extend
that
and
in
the
first
iteration
I
I
just
want
to
get
the
Papa
to
work
in
a
way
that
lets
us
run
it
against
HTTP
API
exposed
by
go
or
Jas
and
I
believe
in
tool
like
J's,
puppeteer
or
some
or
something
like
that.
We
should
be
able
to
like
pass.
If
you
want
to
run
against,
go
or
yes,
maybe
that
could
be
like
IP,
fsd
control
or
other
library
which
we
already
have
as
a
part
of
edger.
A
A
So
it's
possible
that
from
this
we
will
simply
contribute
patches
to
edger
and
there
will
be
an
option
to
to
run
material.
That's
why
so?
The
four
initial
version
I
think
we
should
just
like
see
what
we
can
do
with
puppeteer.
That
will
test
the
guy
in
chromium,
but
it's
like
80%
of
market,
so
pretty
good
for
like
POC,
and
then
we
can
see
what
we
can
test
with
puppeteer
Firefox
and
there's
puppeteer
electron
I'm,
not
sure
how
viable
those
are
I
know
like
Firefox.
A
One
has
implemented
most
of
80
is
so
we
may
need
to
skip
some
tests
until
support
for
specific
API
lands
in
Firefox,
but
I
feel
that's
a
pretty
viable.
So
that's
also
this.
This
version
be
like
this
scenario.
B
is
also
something
I
feel
does
not
require
us
to
invest
as
much
time
as
alternative
ones,
because
if
we
go
here,
we
need
to
like
refactor
tests
without
like
any
guarantee
of
success,
or
it's
pretty
hard
to
estimate.
A
If
it's
even
worth
it
to
touch
like
mocha
tests,
we
can
actually
effectively
test
only
about
end-to-end
right
and
in
C
like
they're
high,
like
we
can
always
later,
we
can
decide.
Oh
actually,
a
lot
of
the
stuff
we
want
to
write
for
B
is
already
implemented
by
some
other
project,
but
I
feel
at
this
stage
we
probably
would
should
go
with
B.
A
That
would
be
my
recommendation
and
try
to
like
basically
improve
puppeteer
setup
and
then
maybe
back
ported
to
agile
I,
also
like
evaluated
to
edge
here
from
the
perspective
of
making
it
easier
for
external
contributors
by
bringing
both
familiarity
and
keeping
our
code
rules
in
check.
So
not
not
only
is
used
for
running
tests,
but
there
are
also
like
built-in
tools
for
checking
bundle,
size,
reporting,
code
coverage
to
external
service
and
also
linter
adjure
comes
with
default
standard
based
set
of
rules
which
are
also
hardened
compared
to
the
defaults.
A
So
I've
run
tests
against
like
web
UI
code
by
using
edgers
rules,
and
we
got
like
60
like
around
50
errors.
So
it's
the
rules
are
a
bit
more
strict
is
its
most
like
cosmetic
changes,
but
it
keeps
code
base
more
aligned
with
like.
If
someone
starts
between
ipfs,
they
will
basically
be
required
to
follow
seminar
code
practices.
It's
those
are
sort
of
like
cosmetic
things.
We
probably
should
not
discuss
right
now,
but
I
just
mentioned
that
as
the
only
thing
that
would
be
worth
for
keeping
adjure
in
the
project.
A
A
How
would
the
running
web
UI
from
JSI
TFS
tests
should
look
like
so
for
a
little
bit
of
context?
If
you
run
CI
objects,
API
FS,
there's
a
special
there's,
a
special
type
of
test.
We
run.
We
run
just
a
we're,
an
external
project
against
a
new
version
of
Jace
IVFs,
which
is
pretty
interesting
because
you
are
able
to
test
if
your
project
is
breaking
some
important
part
application.
So
here,
for
example,
we
check
we
run
a
qfs
companion
tests
against,
like
Jace
ipfs
revision.
I,
believe
you
can
see.
We
can
specify
any
comment
here.
A
So
it's
not
like
this
test.
External
comment
comes
from
major,
but
it's
not
like.
We
need
to
use
this.
We
could
have
our
own
command,
so
it's
not
like
switching
to
edger
or
like
using
edger,
for
this
is
not
hard
to
comment.
Actually,
this
command
is
used
by
edger
in
J's
ipfs
and
it
simply
runs
test
command
in
specific
report.
A
So
don't
need
change
we
would
have
to
do
is
to
ensure,
if
you
are
running
in
CI
environment
run
not
only
just
tests
but
also
end-to-end,
and
that
would
effectively
when
you
run
test
just
test
come
out
right
and
that
would
effectively
give
us
this
capability
of
running.
Let's
say:
Jess
a
profess
against
web
UI,
repo,
more
or
less
I
hope
I
did
not
glance
over
too
much
and
also
did
not
worry
too
much.
If
you
have
any
questions
or
thoughts
after
children.
C
Thanks
for
the
detailed
walkthrough
of
the
options
and
the
scenario
they're
betting
on
puppeteer
sounds
prudent.
The
goal
and
the
Firefox
meldman
team
is
to
support
it
fully
and
move
to
it
for
testing
for
a
bunch
of
things.
So
that's
a
safe
bet
on
that
and
yeah.
It's
a
said.
It
seems
a
priority
from
the
work
that
they've
been
doing
I
based
on
chrome,
dev
summit.
Yesterday,
puppeteer
came
up
several
times
and
it
is
their
standard
and
then
the
side
benefits
are,
as
you
said
like.
C
Not
only
do
we
get
chrome
support,
which
is
you
know,
of
course,
market
heavy
weight
there,
but
also
any
chromium
based
browser
also
will
have
puppeteer
support
built
in
so
we
get
double
benefits.
There.
I
had
a
question
about
how
a
lot
of
this
you
know.
The
the
plan
that
you
talked
about
was
about
testing
against
the
HTTP
API.
A
A
C
C
A
It's
something
I
would
want
to
pick
Hugo's
brain
cause,
I'm,
not
sure
if
he
was
around
when
the
decision
to
like
be
very
opinionated.
Around
mocha
and
karma
happened,
like
those
decisions,
make
perfect
sense
for
all
the
libraries
we
could
produce.
It
saves
everyone
ton
of
time,
including
me.
The
problem
is,
it
was
like
GUI
applications.
Web
applications
are
not
in
the
picture
and
I
feel.
A
We
should
also
look
in
the
dogs
working
group
into
this
discussion
at
some
point,
because
they
will
have
some
interactive
elements
on
ipfs
io
on
the
dog's
IP
of
Sao,
maybe
even
proto
school,
when
we
like
start
do
end-to-end
testing
and
not
just
like
unit
tests
for
small
chunks
and
components.
We
probably
then
could
leverage
the
fact
that
there's
a
peer
support
in
a
chip,
I'd.
A
A
Yet
so
that's
more
more
or
less
my
thoughts
and
we
I've
seen
you
you
wanted
to
get
an
update.
I
did
not
want
to
like
pull
request,
the
something
like
switching
to
Jays
puppet
here
and
all
the
other
stuff
without
like
synchronizing
first,
and
is
this
something
you
feel
make
sense
or
I
was
not
around
the
discussions
when
the
puppeteer
setup
happened,
I
believe
all
he
was
around.
Do
you
remember
what
was
like
the
historical
context
for
that
I.
A
Right
so
probably
Olli
is
another
person
we
should
check
in
just
to
make
sure
we
did
not
like
miss
any
unknown
unknowns
around
around
the
setup,
but
I
feel
like
based
on
what
I've
seen
the
puppeteer
is
a
way
to
go
the
one
we
have
right.
Now,
it's
very
like
super
lin-manuel.
We
probably
will
need
to
add
some
like
make
it
more.
Generic.
C
Sound
sounds
like
there's
almost
a
direction
yeah.
We
have
yet
to
determine
that,
but
a
very
happy
with
the
view
of
the
options
that
we
have
and
it
sounds
like
it
sounds
like
we
probably
have
a
direction.
So
that's
very
exciting
that
wins
once
once
we
have
this
stuff
in
place.
We
will
sleep
better
at
night
and
move
the
spinner
time
on
more
fun,
stuff,
yeah.
A
C
Just
a
quick
note
about
the
invite
that
I
sent
out
this
morning
for
the
two
of
you
and
designer
Jim
kösem,
who
is
working
with
us
to
compile
the
ipfs
browser
into
sign,
CAD
lines.
I
will
spend
about
45
minutes
tomorrow
morning
running
through
just
a
quick
little
exercise
that
he
has
for
us
so
that
to
make
sure
that
he
understands
the
perspective
that
we
have
as
the
developers
of
IP,
fest
GUI
products
and
projects
that
will
help
frame
the
research
work
that
he's
doing
over
the
next
two
months.
C
So
he
started
earlier
this
week
and
we're
hoping
to
hopefully
get
it
done
before
the
holidays.
It
some
might
need
to
be
a
little
bit
postponed
passed,
but
the
goal
is
to
have
it
done
before
December
20th.
So
that
should
be
a
short
one.
This
next
item,
and
also
yesterday
I,
went
to
chrome,
dev
summit
day
two
I
applied.
It
got
rejected
that
at
six
o'clock,
Monday
night
they're,
like
hey,
you
want
to
come
today
to
like
okay,
I
guess:
I'll
go
it's!
C
Day
two,
if
you
look
at
the
screen
that
I'm
sharing
this
first
talk
in
the
morning,
was
the
one
that
I
really
wanted
to
go
to,
and
this
was
Chris
Wilson
a
longtime
web
standards.
Person
were
Microsoft
for
many.
Many
years
worked
at
Google
for
the
last
some
odd
years.
Him
and
yob
Weiss,
the
chairs
of
the
YW
c
g
and-
and
they
are
a
you
have-
is
the
basically
like
the
api,
a
gatekeeper
for
web
api
implemented
in
blink.
C
So
this
was
a
kind
of
deep
dive
talked
into
the
process
that
that
blink
as
a
as
a
rendering
engine
uses
to
be
able
to
test
out
new
web
api
is
figure
out
what
changes
they're
gonna
make
to
the
version
of
the
web
platform
that
they
implement
and
ship
and
all
an
understanding
of
the
different
places
where
the
conversations
happen,
how
features
a
future
proposals
are
evaluated
and
so
whitney
all
the
intent
to
emails.
Things
are
so
it
was.
C
It
was
nice
to
be
able
to
have
a
broad
perspective,
like
kind
of
an
view
of
how
they
do
that
evaluation
from
beginning
to
end.
This
is
really
important
for
the
work
that
we
need
to
do
as
eventually
we
get
I've
confessed
implemented
into
native
support
and
chromium.
This
would
be
kind
of
thing
where
we
okay,
but
what
does
it
mean
to
be
able
to
be
on
or
off
by
default?
Was
it
means
be
in
order
to
trial?
C
I
think
what
for
me,
the
takeaways
were
the
plan
to
engage
more
strongly
with
both
the
w3c
and
the
ITF,
at
least
at
a
visibility
perspective
of
the
goals
that
we
have
as
an
organization.
Spl
in
2020
is
even
more
more
important
because
we're
going
to
be
like
we
need
to
be
able
to
create
an
environment
where
we
can
have
a
conversation
about
visas
cases.
The
ipfs
browser
design
guidelines
will
also
help
support
creating
that
environment.
Having
this
conversation
in
2020
that
can
lead
us
to.
C
You
know
a
post,
post,
2020
possible
native
implementation
that
people
could
actually
flip
on
and
it's
someday
in
bigger
browsers.
So
that
was
really
cool.
Talk
that
a
lot
of
the
rest
of
it
was
more
web
developer
focused
the
HTML
done
in
session
was
really
good
and
that
it-
and
these
are
all
recorded,
so
you
can
watch
them
I,
don't
know
if
the
videos
are
up
yet,
but
it
was
good
in
that
it.
C
If
you're
not
familiar
with
how
long
it
can
take
to
get
change
to
happen
in
the
web
platform,
that
they're
celebrating
things
like
styling
of
form
controls
and
it's
good
like
it's,
some
of
these
changes
are
hard
to
make
and
it's
important
that
we
do
celebrate
them
as
the
web
platform
gets
better
for
designers
and
developers.
But
at
the
same
time
it's
a
really
good
illustration
of
how
long
it
takes
for
things
to
happen.
C
Things
like
CSS
grid
all
landed
at
once,
and
it's
an
example
of
where
there
was
some
coordination
between
browser
vendors
and
making
sure
that
a
technology
that
was
important
impactful
was
able
to
get
to
developers
and
designers
hands
relatively
quickly.
But
if
you
look
at
the
history
of
the
technology,
it
took
about
eight
years,
all
total.
So
we
are.
We
are
not
even
really
at
the
presentation
stage
of
that
with
things
like
IP
FS,
but
given
the
the
the
strategic
approach
that
we
want
to
take.
C
They
are
a
group
of
people
that
do
or
do
not
work
together
same
way
that
any
organization,
a
group
of
people
so
think
things
got
a
little
spicy
in
the
in
the
QA
and
so
that
that
was
worth
walking
watching.
From
that
perspective.
Also
related
to
us
was
the
this
talk,
Chrome
extensions
in
the
world
of
tomorrow.
This
is
where
something
presented
their
work
on
manifest
v3
and
by
by
all
accounts,
there
was
almost
no
acknowledgement
whatsoever
that
it
was
a
thing
that
was
controversial.
C
Instead,
it
was
presented
as
a
beautiful
new
future
with
better
performance
and
a
user
centered
attitude,
so
it
it
was
good
to
be
able
to
get
the
clarification
that
no
they're
not
backing
down
on
v3.
Yes,
they
are
leaning
and
hard,
and
you
they're
right
we're
all
wrong
and
users
actually
don't
want
to
add
puckers.
C
C
Also
did
have
so
they
had
a
browser,
other
browser
row,
kind
of
thing
with
like
Samsung
and
edge
and
Firefox
and
I
did
talk
to
that
edge
folks
and
a
little
bit
and
they
I
guess
the
the
most
important
piece
of
information
that
I
got
really
because
it
was
more
like
Beverly's,
not
what
it
doesn't
seem
like.
These
are
not
the
web
standards
decision
makers.
C
There
wasn't
the
product
manager
or
anything
like
that
that
if
you're
using
Mac
and
you're
testing
edge
for
Mac
there
that
all
the
features
design,
everything
is
exactly
the
same
as
on
Windows.
So
from
a
friend
in
perspective
and
from
a
you
know,
understanding
feature
capability,
and
things
like
that
is
functionally
the
same
so
which
was
nice
to
be
able
to
say
yeah
I
can
test
edge
on
Mac
without
having
to
you
when
Windows
would
be.
It
also
means
that,
from
the
browser
design
guidelines
work
that
we're
doing
we
can
easily.
C
A
A
If
anyone
is
interested
in
details,
I
sort
of
like
updated
that
there's
like
in
2018,
we
had
signed
HTTP
exchanges,
which
was
simply
like
one
HTTP
request
packaged
signed,
and
then
you
could
load
it
and
it
looks
like
it
came
from
some
origin,
but
that's
a
lie,
and
then
this
quarter
bundled
HTTP
exchanges
rebranded
as
web
bundles,
which
is
pretty
cool,
name
landed.
So
that's
a
group
of
resources
bundled
together
and
you
can
load
like
an
entire
website
from
a
file
which
has
like
a
specific
extension
and
mime
type
in
chrome.
Right
now.
A
A
Finally,
it
feels
like
it's
polished
enough
to
the
point.
We
can
start
thinking
about
bundling
websites
and
when
that
technology
lands
and
it
will
land
right
now,
it's
like
origin,
trial
or
in
behind
the
flag,
because
it's
like
highly
experimental
but
within
like
six
months
or
something
it
will
be
available
in
like
a
stable
chromium
and
that's
the
kaity
percent
of
the
market.
So
people
will
start
using
this,
and
the
cool
thing
is
that
it
will
work
on
mobile
as
well
and
like
mobile,
is
a
very
important
part
of
the
story.
C
Yes,
that
I
think
the
bundles
is
is
an
inevitability.
That's
at
least
in
chromium
in
it
was
something
and
I
don't
know
if
I
think
they
announced
it
and
presented
it
on
day
one,
but
in
day
two
that
came
up
several
times,
and
the
interesting
thing
is.
That
is
not
really
like
a
packaged
app
like
the
way
an
apk
is,
but,
as
you
say,
it
really
is
like
a
record
and
replay
of
HTTP
transactions
and
I.
Think
that
challenge
that
they'll
have
is
from
a
developer
ergonomics
standpoint.
C
That
seems
awkward
and
that's
one
of
the
challenges
that
I
think
that
that
they've
had
so
far
is
that
they're
using
that
in
order
to
be
able
to
to
fit
in
seamlessly
with
the
and
the
farthest
edge.
Node
of
that
browsers,
operational
operationalization
of
the
security
model
like
we
don't
have
to
change
anything
and
the
browser
is
still
a
request
response.
It's
just
fake.
A
C
A
Still
steal,
X
I'm
still
excited
cause
like
signing
is
optional,
so
even
if
you
are
skittish
about
breaking
like
spoofing
TLS
for
like
archival
purposes,
it's
worth
thinking
about
yeah
or,
let's
say
Wikipedia,
and
you
want
to
all
the
citations
you
want
to
like
attach
them
to
page
when
we
edit
it
so
they
don't
disappear.
Stuff,
like
that,
you.
C
C
We
are
all
separate
on
these
frozen
wastelands
event,
Arctica
and
camps
alone
and
sad.
Is
there
any
specific
goal
that
we
want
to
come
out
of
that
week
with
any
specific
project
that
we
would
like
to
do?
We
have
talked
about
this
a
couple
different
times.
Do
we
want
to
come
out
with
say
a
a
clear
decision
about
the
test
framework
approach
would
probably
be
good
because
we'll
have
easier
people
and
other
people
in
the
same
general.
B
A
A
A
C
C
If
we
hit
a
wall
there,
let's
be
very
aware
of
that
and
make
sure
that
our
primary
goal
of
making
sure
that
understanding,
where
j/s
and
go
I
profess
changes,
break
web
UI
and
vice
versa
and
companion,
and
vice
versa-
that's
our
primary
goal
here.
Maybe
there
is
a
side
effect
of
puppeteer
and
easier
that
helps
general
website
testing
for
people
developing
websites,
regular
HTTP
websites-
if
you
know,
but
they
seem
to
be
different
enough,
then
I
want
to
make
sure
that
the
one
doesn't
block
the
other.
A
Like
the
second
thing
is
sort
of
like
picking
up
research
made
on
pinning
QX
made
by
M
job
shall
depart
its
project
moved
to
community,
but
generally
there's
a
lot
of
material.
She
created
in
collaboration
with
me,
Hector
and
others
on
sort
of
like
she
made
a
very
good
pass
at
State
of
the
Union
of
pinning
across
all
our
GUI
applications
projects
not
only
like
ipfs,
but
also
cluster
cuz
like
pinning
means
sort
of
has
a
specific
language
and
meaning
in
cluster
and
that
sort
of
a
different
meaning
in
vanillite
EFS.
A
And
then
we
got
our
gooeys,
which
sort
of
dot
always
follow.
What
low
lower
levels
do
and
that's
more
could
be
interesting,
an
exercise
in
alignment
to
to
come
up
with
a
plan
how
to
remove
those
differences
which
are
sort
of
like
a
heavy
something
sometimes,
as
those
are
really
heavy
blockers
for
newcomers
to
the
project
when
people
add
stuff
to
ipfs
from
common
line,
and
they
don't
see
them
in
webui
or
they
add
the
same
file
from
common
line
using
odd
and
files
right
and
they
get
different.
C
IDs.
A
That's
also
kind
of
related
to
the
proposal
of
files
v2,
but
only
in
in
the
fact
that
that
proposal
comes
with
some
very
good
naming
conventions
and
the
new
language
which
we
could
reuse
before
even
adopting
that
standard.
But,
let's
say
switch
UI
from
like
remove
pinning
as
a
word
from
you
eyes
and
simply
like
you,
don't
upload
to
ipfs
you
just
import
stuff
to
your
node
and
that's
very
important,
cut
up
cause
upload
suggest
it's
like
pushed
to
some
third
party
server
right.
It's
not
true!
A
You
import
it
to
your
local
node
and
unless
someone
requests
that
data
from
you,
it's
only
on
your
local
node
things
like
that,
not
sure,
if
I'm,
a
very
coherent
in
like
communicating
what
I
mean,
but
generally
extracting
next
steps
from
this
pinning
research
and
I
feel
those
steps
would
be
like
pretty
simple,
but
we
need
to
like
coordinate
across
both
command
line.
Go
ipfs,
JS
ipfs,
as
as
a
GUI
and
in
web
browsers,
just
to
simply
either
change
the
language
or
update
dogs.
A
C
Kenny
I
I,
agree,
I
would
love
to
be
able.
We
have
enough
and
we
might
have
enough
people
with
shared
interests
in
separate
places
far
apart
from
each
other,
to
build
to
have
a
great
conversation
about
that.
The
can
you
link
to
any
of
those
assets
if
there
is
that
work
as
public
at
all,
oh
yeah
we'll
be
great
to
have
in
the
notes,
so
that
people
can
reference.
It
seems
like
something
we
probably
want
to
share.
C
Following
called
the
Colin
fruit
issue
around
adding
file
directly
from
web
UI
a
to
NFS,
you
know
you
thought,
there's
a
long
history
of
design.
Thinking
around
this,
the
the
various
places
where
we
have
functionality
exposed
and
the
language.
That's
used
it
years
worth
of
design
thinking,
and
it
would
be
great
to
be
able
to
have
some
conclusions.
C
A
And
it
feels
mostly
because
there
were
more
important
things
and
time
passed,
and
now
it's
actually
a
problem
that
we
don't
have
this
coherent
language
around
some
basic
concepts
such
as
keeping
stuff
around.
We
have
pinning
implicit,
pinning
like
Emma
first
other
stuff
found
resource
I'll
drop
it
in
in
the
notes.
There's
a
entire
issue
of
work
done
by
megahertz,
but
I
believe,
like
the
last
comment,
has
sort
of.
Like
summary,
the
links
to
summary
documents.
There's
a
PDF
of
all
the
work
she
did
so
I
believe,
like
maybe
I'll,
also
link
the
PDF
directly.
C
So
I
said
those
two
things
alone
would
be
great
for
love.
We
connect
sure
other
things.
What
will
come
up
specifically
testing
opera
builds
in
person
will
be
fun,
especially
in
the
local
network,
together,
maybe
against
local
gateways.
It
should
be
pretty
interesting,
but
I
added
two
more
quick
things.
I
know
we're
really
running
out
of
time
here,
and
this
was
going
to
be
the
short
short
one.
That's.
A
C
I,
we
should
probably
close
up
thanks
for
adding
thanks
for
a
timeboxing,
also
my
PFS
policy
issue.
You
should
take
a
look
at
that
and
close
it
out
and
add
a
PR,
so
I'll
got
to
my
list.
Take
a
look
at
and
then
do
we
have
any
highlights
to
add
anything
released
this
week.
Anything
that
we
want
to
share
with
the
team
next
week.
C
A
The
Pierce
page
did
not
display
peers
with
WebSocket
star
multi
others,
because
no
one
actually
ever
had
to
load
web
UI
with
those
peers
because
it
never
because
you
were
not
able
to
load
web
UI
in
with
embedded
J's
ipfs
in
web
browser
until
we
did
that
in
brave.
So
that's
pretty
pretty
interesting.