►
From YouTube: Octant Community Meeting - February 17th, 2021
Description
Octant community meeting is held weekly. We discuss and talk about the current state and future of Octant, demo upcoming features and releases, and preview new ideas we are considering for Octant.
Meeting agenda: https://hackmd.io/CzaPxtmXT_SW8nEpdwvGzw?view
A
All
right
everybody
welcome
to
the
was.
I
always
got
a
look
february,
17th,
throw
it
on
my
screen
too
february
17th
acting
community
meeting.
It's
a
fun
one
today,
because
we
have
a
few
things:
we're
gonna,
we're
gonna,
welcome
some
new
members
to
the
team.
We're
gonna
celebrate
the
release
a
little
bit
and
then
we're
gonna
talk
about
contributing
to
octant
and
then
maybe
do
some
some
for
good,
first
issue,
labeling
and
yeah.
So
with
that
I
will
I'll
just
say:
let's
welcome.
A
We
have
some
new
members
to
the
to
the
octane
team,
so
luis,
felipe
and
vikram
are
joining.
The
acting
team,
luis
and
felipe
are
joining
full-time
and
vikram
is
on
an
eight-week
rotation
from
from
another
team
within
vmware.
So
that's
very
exciting
for
us.
So
I
wanted
to
give
luis
and
felipe
a
moment
to
to
say
hi
to
folks,
so
I
think
they're
both
on
this
call
yeah.
They
are.
B
Yes,
hello,
my
name
is
felipe.
I'm
really
excited
to
to
be
part
of
this
team.
The
the
past
meeting
was
very
helpful
to
me
to
get
to
know
more
the
product
we
are
designing.
We
are
coding
here,
I'm
actually
learning
go
from
the
beginning,
I'm
doing
a
a
course
in
udemy.
I
have
a
book
to
read
about
cubernet,
so
I'm
gonna
start
a
little
slow,
but
I
hope
to
get
to
improve
my
my
knowledge
quickly
to
star
contributing
to
the
team.
C
Hi
hello,
my
name
is
louise.
I
am
from
colombia,
I
I'm
pretty
new
with
the
team,
but
I'm
very
excited
about
the
product
and
that's
it
for
me.
Thank
you.
A
Excellent
and
vikram,
if
you're
here,
if
you
want
to
take
a
moment
to
say
hi
to
folks.
D
Hey,
I'm
vikram
I'm
a
new
engineer
on
rockton
team
and
I'm
trying
to
include
the
dev
consultant.
A
Yeah
so
yeah
thanks.
Everyone
welcome
and
yeah
really
excited
to
have
some
new
folks
on
board,
so
keep
an
eye
out
for
them
and
the
slack
channels
and
showing
up
on
some
issues
we
do
have
the
they'll
be
they'll,
be
the
first
people
to
to
be
going
through
the
official
documented
process
of
community
membership.
So
that's
that's
funny
so
yeah.
Looking
forward
to
that.
A
So,
moving
on
to
oh
17
is
releases.
This
one
is
what
I've
typed
there.
Oh
17
is
releases.
We've
released
it
it's
it's
it's
published
there.
There
has
been
a
a
few
issues
opened
since
it
was
published,
which
we've
captured
one
that
milan
discovered
this
morning
around,
but
not
deleting
zoom
in
a
bit
here
around
it,
not
deleting
resources,
which
seems
odd,
but
it
is
true,
so
we're
gonna
we're
taking
a
look
into
that
and
then
the
other
one
was
around
cpu
cycles.
A
It
seems
like
it's
not
it's.
It's
burning
more
cycles
than
it
should,
especially
when
it's
minimized
to
the
tray.
So
though,
really
octant
doesn't
really
change
its
behavior
when
you
minimize
it
to
the
tray
it
just
which
is
no
longer
on
your
screen.
So
so
you
would
expect
it
to
use
some
cycles,
but
this
was
reported
by
scott
andrews
as
using
a
lot
like
147
of
cpu
time.
So
definitely
not
okay,
so
we're
gonna
have
to
immediately
take
a
look
into
that,
as
well
as
the
delete
issue.
A
Good
news
is
things
do
seem
to
be
working
besides
that.
E
A
Oh
and
the
mac
code
signing
yeah,
so
this
is
something
that
we
knew
as
we
released
this.
But
when
you
launch
the
application
in
mac,
you
will
need
to
alt
click
and
then
select
open
because
it
is
currently
not
signed.
We
are
working
through
that
process
or
we're
going
to
be
working
through
that
process
internally
to
figure
out
exactly
what
it
means
to
get
this
thing
signed
now
that
we
have
it
built
as
a
as
an
electron
application,
so
stay
tuned
for
that.
A
Well,
we'll
update
you
all,
as
as,
as
we
know
more
and
as
we
find
out
what
what
release
we'll
have
signing
officially.
A
So
I
think
that's
it
for
the
main
updates
of
o17.
So
I
just
want
to
say
thank
you
to
everyone
who
was
involved
in
the
017
release
and
sam
and
milan,
pia
isha.
There
was
a
there's,
a
long
road
there
through
breaks
and
holidays
and
and
all
sorts
of
stuff.
So
it's
really
good.
It's
a
good
one
to
get
out.
So
I
really
appreciate
everyone's
time
and
effort
there
and
I
think
we've
done.
We've
done
a
good
job
with
our
with
our
first
electron
release.
A
So
far,
oh,
and
and
this
is
something
that
sam
mentioned-
that
I
wanted
to
call
out
the
so
the
octant
package
for
installers
will
be
octant
desktop
so
that
that's
how
you'll
get
the
new
electron
version.
A
The
old
octant
recipe
for
various
package
managers
will
continue
to
be
updated
with
the
command
line
version
that
we
have
now
with
a
deprecation
warning
coming
soon
to
let
you
know
that
octant
desktop
is
the
future,
so
we
don't
have
an
official
release
like
I
don't
know
officially,
when
the
command
line
version
will
will
stop
being
updated
in
the
package
manager.
Formulas,
probably
we'll
probably
give
it
two
or
three
and
we'll
be
sure
to
put
that
information
somewhere
publicly.
A
The
exact,
like
version,
count
we're
gonna
when,
when
we're
gonna
stop
shipping
it
to
package
managers,
as
I
mentioned
previously,
the
command
line
version
will
still
be
built
as
a
nightly,
and
it
will
still
be
available
in
the
releases
that
get
published
up
to
wait.
No
it'll
only
be
available
as
a
nightly.
It
will
no
longer
be
in
the
releases
that
get
published
to
package
managers
or
in
our
releases
tag
assets
or
releases
assets.
So
keep
that
in
mind
as
things
move
forward,
we
will
probably
for
the
next
version.
A
I
don't
know
if
we'll
get
the
deprecation
warning
in
for
this
one.
If
we
do
then
it'll
be
there,
but
if
not
it'll
be
in
the
next
one,
and
then
that
one
we'll
have
specific
language
about
how
many
versions
you
can
expect
before
it
stops
getting
updated.
A
We
won't
be
removing
that
formula,
we're
just
going
to
stop
updating
it
eventually
we'll
remove
it,
but
we
want
it
there
a
while,
so
that
people
can
get
the
warning
and
know
to
use
the
new
one.
E
No,
I
just
wanted
to
comment
it.
It
feels
a
little
weird
to
call
it
the
command
line
version,
because
when
I
think
about
command
line,
I'm
thinking
like
two
tools,
like
I
don't
know,
cube
couple
or
something
like
that,
so
it
might
be
a
little
confusing
and
just
think
it
might
be
good
to
find
a
little
better
name.
Yes,
we
do
have
a
desktop
which
is
electron,
but
what
used
to
be
octant
running
a
browser?
A
I
mean
you,
do
you
do
a
cube,
ctl
proxy
and
then
you
open
up
a
thing
in
a
browser.
Cube
ctl
is
still
a
command
line
tool,
it's
run
from
the
command
line
and
in
fact,
in
windows
the
old
octant
binary
would
not
even
launch
unless
you
were
in
the
command
line.
It
would
tell
you
this
is
a
command
line.
Application
go
launch,
it.
A
E
Just
a
little
confusing,
it
feels
a
little
confusing,
I'm
the
only.
A
F
Yeah
it'll
just
be
a
time
thing
like
you
know,
we
don't
really
have
to
delve
into
a
semantic
argument
of
what
constitutes
as
a
command
line
tool,
but
like
this,
like
you
know,
and
about
the
course
of
like
one
release,
this
whole
situation
is
moved
anyways.
E
A
A
So
that
covers
the
release,
and
then
I
wanted
to
so
we're
going
to
be
at
the
end,
we're
going
to
use
the
the
the
final
bits
of
time
here
at
the
end,
to
do
like
a
high
level
overview
of
the
octane
system.
For
folks
who
are
interested
in
contributing
to
octan.
A
Since
we
do
have
some
new
people
who
are
going
to
be
contributing
to
octan,
we
thought
it
was
a
good
time
to
kind
of
do
that,
share
out
more
generically
with
with
the
whole
community,
so
that
other
folks
who
are
watching
this
are
interested
can
can
get
some
of
that
information.
F
Same
sure,
so
this
one
is
something
I
threw
on
the
slap
channel
yesterday
didn't
really
get
a
response
from
anyone,
but
just
gonna
ping
it
again.
So
the
idea
is
that
I've
labeled
a
few
issues
as
good
first
issues,
and
that
is
debatable.
What
constitutes
a
good
first
issue,
for
example,
something
like
how
do
you
add
a
new
component,
an
octane
and
it's
not
necessarily
difficult
as
more,
is
just
really
verbose
and
involves
touching
a
lot
of
files
and
objects.
F
So
I
was
thinking
of
using
that
as
an
opportunity
to
do
a
pairing
session
with
some
of
the
new
members
of
the
team.
However,
if
there
is
community
interest
in
building
out
new
components
over
time,
it
might
just
be
time
better
used
to
record
some
of
this
stuff
and
maybe
narrate
over
it
or
even
try
to
generate
like
a
lengthier
piece
of
documentation
over
it,
instead
of
just
making
it
an
internal
meeting
where
I
just
sit
with
folks
for
like
a
few
hours
to
knock
out
a
new
feature.
F
So
I
wanted
to
see
what
the
community
expectations
are
like.
Let's
say
if
someone
wanted
a
new
component,
is
this
like
hey,
we'll
ask
the
octa
team
to
do
it
and
they'll
do
it
and
expect
it
in
the
next
release,
or
is
this
something
that
we
want
to
see
more
community
contributions
to
so
do
we
like,
if
there's
a
component
that
doesn't
exist,
do
we
want
the
community
to
start
chipping
in
and
to
build
those
components,
and
I
I
think,
like
besides
scott
rosenberg,
I
don't
think.
C
F
Or
maybe
people
on
youtube
might
be
listening
in,
but
I
think
it's
just
more
of
a
general
ping.
I
think
like
any
any
time
scheduled
for
something
like
this.
I'm
gonna
schedule
this
for
next
week.
So
if
there
is
interest
for
something
like
this
just
kind
of
ping,
on
slack
or
pm,
let
me
know-
and
we
can-
I
can
talk
with
the
team
and
see
what
we're
gonna
do
about
it.
A
Awesome
yeah.
Thank
you,
sam
yeah.
I
think
we
can
we
can
also
if
we
want
to
make
a
note
there,
we
can
share
that
idea
out
on
on
twitter
as
well.
So
that
way
we
get
a
little
more
engagement,
just
get
more
eyeballs
on
that
idea.
I
think
I
think
there's
probably
is
some
people
who
would
love
to
see
longer
form
sessions,
especially
around
the
like
adding
components
and
building
out
plugins.
E
Yeah,
especially
building
plugins,
that
seems
like
a
must
to
me.
You
know
it
would
be
really
good.
I
think
it
will
help
a
lot
of
people
kicking
them
off
on
their
plug-in
journey.
Just
to
have
a
video
tutorial
a
bit.
You
know
kind
of
step-by-step
approach.
What
needs
to
be
done?
What
are
the
possibilities,
options
or
things
like
that?
So
I
think
that
would
be
really
really
useful.
G
Yeah
I
know
for
myself.
The
plugins
would
be
very
useful
because
I
definitely
have
been
looking
at
creating
some
plug-ins,
so
that
would
be
very
useful
for
my
perspective,.
A
There
you
go
sam
now,
you
know,
I
think
that's
like
to
me.
That's
that's!
That's
enough!
Like
that's
enough,
I
think
it'll
be
useful,
so
yeah
we
can
try
to
carve
out
some
time.
For
that.
Let
me
do
yeah,
we'll
figure
it
out,
we'll
figure
out
what
that
looks
like,
and
I
think
it'd
be
nice
to
have
the
live
session
paired
with
a
blog
post
or
a
script
or
some
documentation
so
that
you
can
follow
along
with
too.
A
All
right,
I'm
gonna,
okay,
so
that
that
covers
the
the
updates
from
the
o17
release,
welcoming
some
new
folks.
So
what
I
wanted
to
do
now
was
do
a
kind
of
a
brief
high-level
overview
of
octant
and
specifically
from
an
engineering
viewpoint,
and
so
the
way
I'm
gonna
do.
This
is
a
little
different
than
in
the
past.
In
the
past,
we've
just
done
like
straight
code
walkthroughs.
A
Those
are
very
dense.
Those
are
really
hard
to
like
keep
focused
and
attention
on
as
you're
diving
in
like
spelunking
through
all
of
these
deeply
nested
methods
and
interfaces
and
abstractions.
A
So
I'm
gonna
try
something
different,
which
is
I'm
going
to
focus
on
the
high
level
abstractions
and
then
I'm
going
to
have
octet
running
while
we
step
through
those
and
and
show
directly
where
those
high
level
abstractions
end
up
when
you're
viewing
octant,
and
I
think
that
may
provide
a
good
foundation
for
folks
who
can
then
take
that
and
dive
deeper
into
the
actual
go
code
and
like
looking
at
how
these
things
are
implemented.
I
think
that's
just
a
better
foundation
so
after
this
is
over
feedback
welcomes.
A
If,
if
you
you're
like
no,
I
would
really
like
a
deep
dive
into
code.
We
can
also
do
that
at
another
at
another
meeting,
but
this
so
that's
the
approach
for
for
this
one.
So
let
me
share,
let's
see,
there's
there's
a
way
to
share
like
because
I
want
I
want
both.
A
A
A
A
Okay,
so
I
will
open
up.
I
have
this,
which
I
created
and
zoom
in
on
it
here,
like
that:
okay,
one
yeah,
one
more
okay,
so
on
the
right-hand
side
is
octan
on
the
left-hand
side
is
a
high-level
kind
of
representation
of
the
various
parts
that
make
up
a
make
up
an
octet
module
and
the
data
flow
out
of
a
module,
how
it
gets
things
from
the
cluster
and
and
how
it
interacts
with
the
the
user
interface.
A
So
I
think
first,
let's
just
start
with
this
idea
of
of
right
in
the
center,
which
is
the
important
I
think
the
most
important
piece,
because
it's
kind
of
where
everything
gets
integrated
is
the
module.
So
in
octant,
on
the
left
hand
side
you
have
these
these
top
the
this
first
set
of
navigation
cluster
overview
namespace
overview
things
like
that,
so
these
generally
map
to
modules
like
the
applications
module
the
overview
module,
the
cluster
overview
module.
A
So
when
you
see
the
term
module,
think
one
of
these
high-level
interactions,
including
like
plug-in
right,
like
plugins,
can
act
as
modules.
So
in
the
case
of
this,
we
are
in
the
name.
We
are
in
the
overview
module
which
we
have
labeled
as
the
namespace
overview
and
right
now,
I'm
looking
at
the
workloads
overview,
so
this
navigation
that
you're
seeing
from
the
module
is
actually
it's
registered
within
the
module
itself,
as
as
navigation
this.
A
A
So
this
module
defines
its
navigation
and
that
navigation
as
a
result
gets
put
out
onto
the
stream,
which
is
our
our
content
handler
stream.
So
we
can.
Actually
you
know
I
don't
wanna.
I
don't
wanna
do
that.
I'm
gonna,
I'm
not
gonna!
I'm
not
gonna,
wrap
and
hold
that
navigation
rights
to
a
websocket
stream
as
its
own
set
of
content
called
navigation,
and
that
gets
rendered
right
here.
So
each
module
defines
its
navigation,
and
this
is
what
you
see
rendered
out
between
these
two
two
panes.
A
There
is
the
pathmatcher
which
says
the
the
path.
Matcher
is
really
just
a
high
level
piece
that
says,
if
you
see
forward
slash
overview
or
if
you
see
forward,
slash,
applications,
then
route
to
this
module
and
then
so
once
the
path
matcher
is,
is
matched
and
we've
routed
to
the
namespace
overview
or
in
this
case
the
overview
module.
A
A
If
you
do
have
questions
as
I
go,
I
am
moving
through
it
fairly,
quick
just
for
the
sake
of
of
of
time,
but
yeah
I'll
continue,
so
modules
themselves
have
a
set
of
describers,
and
now
the
describer
kind
of
essentially
describes
what
you're
going
to
see
in
this
page
and
how
it
does
that
is,
there's
a
path
filter
which,
when
you
select
items
from
this
navigation,
the
the
the
user
interface
sends
a
set
content
through
the
stream
into
the
handler
right
and
that
set
content
is
handled
by
a
set
of
dispatchers
and
then
saved
into
state.
A
That
content
path
is
used
by
the
path
filter
to
then,
when
the
module
is
rendered
to
say
what
items
should
I
limit
this
describer
to
so
the
the
path
filter
gets
instantiated
and
passed
into
a
describer,
and
is
it
passed
in
or
is
it
used
by
it?
I
believe
it's
passed
in
passed
into
a
describer.
A
A
A
describer
goes
out
through
our
store
interface
and
either
using
an
informer
or
a
client.
The
the
store
interface
will
use
and
I'm
gonna
touch
on
each
of
these
individually.
Here
I
just
want
to
go
through
the
whole
flow.
The
store
interface
will
use
an
informer
or
a
client
to
then
talk
to
a
kubernetes
cluster
and
that
cluster
will
return
the
data
back
into
a
describer
for
either
of
like
a
listing
of
objects
or
a
set
of
details
around
an
object.
A
That
describer
will
then
hand
that
information
over
to
a
generator
which
uses
our
printers
to
take
the
describer
data
and
run
it
through
a
set
of
printers
to
then
generate
content
data
which
is
like
this
table
that
you
see
in
the
center,
where
it's
listing
of
deployments.
A
So
imagine
the
user
interface
says:
hey,
I'm
in
the
I've
set
my
path
to
overview,
so
the
path
matcher
says:
okay
load
the
overview
module,
the
content
type
gets
set
with
the
rest
of
the
with
the
rest
of
the
path.
When
I
click
on
this
navigation
item
for
deployments,
that
then
says,
okay
filter
use
the
path
filter
to
create
a
describer.
That
goes
and
lists
deployments
for
the
cube
system
namespace
those
get
returned
from
the
cluster
and
in
combination
with
our
printers,
which
are
typed
printers.
A
A
So
to
to
now,
we
can
start
to
dig
into
the
the
specifics
and
the
areas
of
of
like
state
and
stream,
which
I
think
will
help
with
showing
exactly
what's
what's
going
on.
A
So
I
will
pull
up
this
here,
so
you
can
see
here
and
maybe
let
me
make
that
a
little
bigger
okay.
So
this
is
the
networking
tab
for
for
octan,
and
this
is
specifically
the
stream.
So,
on
the
left-hand
side,
you
see
stream
data.
This
is
this
is
what
we're
looking
at
on
from
the
client
side,
as
stream
data,
you
can
see
the
content
path
here
is
empty,
so
it's
it's
a
blank
content
path,
which
means
we're
at
the
root
of
this
module.
A
So
there's
no
there's
no
extra
path,
filter
that
we
want
to
show
for
this
module
and
so
and
then
we
can
also
see
we
we've.
We
have
a
set
namespace
which
the
current
namespace
is
default,
that's
set
by
the
client,
and
it
represents
this
namespace
drop
down
that
that.
A
Right
here,
so,
if
I,
if
I
were
to
change
this
namespace
to
say
cubesystem,
you
would
see
we
would
send
a
set
namespace
to
keep
system
the
navigation
right.
The
is
now
the
default
path
has
now
changed
to
overview,
namespace,
cube
system
and
the
filters,
and
everything
else
are
still
the
same,
so
that
that
is
this
piece
right
here:
user
interface,
data
stream,
the
websocket
handler
dispatchers.
This
is
represented
as
that
set
namespace
call.
A
It
stores
that
up
and
state,
then
the
module
uses
that
state
to
well.
That
state
is
used
to
load
the
module.
That
represents
the
the
the
navigation
path.
So
in
this
case
overview,
then
the
this
namespace
cube
system
piece
is
what
is
used
as
part
of
the
filtering.
To
only
show
the
items
for
namespace
cube
system.
A
So
I
think
that
is
okay,
so
that
that
covers
like
the
the
big
pieces
of
of
octant.
And
now
I
want
to
talk
about
how
the
everything
that
is
a
module
is.
A
Composed
of
these
pieces,
so
modules
themselves
do
not
actually
are
a
container
really
to
compose
all
of
these
various
pieces
together.
So
the
like,
when
you're
exploring
octan's
code,
the
describer
and
the
generator
package,
and
all
these
things
they're
separate
packages
that
are
composed
together
within
a
module
to
produce
the
results
that
we
want
same
with,
navigation
right
navigation
gets
defined
for
the
module
it
gets
registered
with
the
main
system,
and
then
it
is
used
to
draw
the
navigation
the
same
with
our
the
way.
The
navigation
draws.
A
A
This
is
the
this
is
coming
from
the
generator.
So
there
is
a
there
is
a
a
loop
running,
an
octant
that
takes
the
data's
from
the
describer
and
runs
it
through
all
of
the
printers
and
returns
that
up
as
a
content
response
into
the
generator
which
is
running
on
a
loop
to
then
produce
this.
This
content
event-
and
you
can
see
it's
all
just
json-
it's
like
a
set
of
components
packed
into
json,
and
that
is
what
we
render
on
the
front
end.
A
So
think
of
this,
like
a
dsl,
a
domain,
specific
language
that
allows
you
to
render
components
on
the
front
end
without
having
to
write
the
javascript
or
the
html,
or
anything
to
do
so,
and
so
that
that
is
how
octant
operates
for
all
of
its
views.
It
is
a
stream
of
data
like,
for
example,
navigation.
A
You
can
see
that
the
various
sections
and
how
they're
defined
how
it
lines
up
with
the
workloads
load,
balancing
sections
and
how
they're
defined
you
can
see
when
you
know
we
expand
those,
and
you
can
see
the
the
paths
and
and
the
things
that
that
gets
set
when
you
click
on
those
right.
So
this
is
the
path
that's
going
to
get
set
for
that
navigation
item.
I
can.
I
can
show
it
just
by
clicking
you
come
down
here.
A
A
This
is
used
by
the
describer
when
it's
calling
into
the
store
interface
to
get
stuff
from
the
cluster,
and
then
this
discovery
and
load
balancing
is
a
section
within
the
within
the
module
that
says
show
it
says,
describe
services
for
it
for
well,
actually,
it
says:
describe
hpa's
ingress
services
and
network
policies.
We
only
have
services
right,
but
that
is
what
that's.
What
the
module
is
told
to
do
is
to
describe
these
four
things
when
you're
on
the
overview
of
the
discovery
and
load
balancing
section
so.
A
That
I
know
that's
a
lot.
It
would
have
been
way
worse
if
I
would
have
done
it
through
code,
but
I
think
this
is
a
good
general
high
level
overview
of
how
octant
works.
One
thing
to
take
note
of
is
our
the
the
pattern
we
try
to
adopt
with
our
state
is
the
only
thing
that,
like
basically
state
exists
here,
and
we
try
to
keep
it
out
of
everywhere
else.
A
We
want
to
handlers,
can
can
use
dispatchers
to
interact
with
state
indirectly,
but
we,
but
we
never
have
direct
access
to
nothing,
is
ever
the
client
is
never
like
flipping
values.
It's
always
coming
through
our
handler
through
a
set
of
dispatchers,
and
then
that
is
taking
the
action
on
state
and
and
then
we're
using
that
state
to
inform
other
areas
of
the
application.
So
state
always
flows
through
the
set
of
dispatchers
and
that's
a
that's
an
important
piece
to
often
and
then
the
other
thing
is
our
store.
A
Interface
is
a
generic
interface
that
allows
get
list,
watch
delete
type
actions.
We
do
not.
We
implement
that
as
something
called
the
dynamic
cache,
but
that
is
that
is
that
is
purely
the
actual
implementation
of
satisfying
a
store
interface
everywhere.
We
then
go
look
up
things
in
our
describers.
We
try
to
use
this
store
interface.
There
are
a
few
exceptions
to
that.
We
are
using
the
cluster
client
directly,
hopefully
we'll
be
moving
away
from
that
soon,
because,
ideally
within
a
module,
the
module
should
not
have
to
care.
A
A
E
No,
I
I
think
this
is
a
great
overview.
This
is
the
the
best
I've
seen
so
far,
and
I
agree
if
you
try
to
do
this
in
code.
E
It's
much
harder
and
that's
just
to
see
the
the
high
level
picture
helps
a
lot,
but
the
the
thing
I
I
I
would
wish
that
you
expand
on
is
to
explain
a
little
more
how
the
when
the,
how
the
the
content
is
created
with
printers
and
how
the
filters
take
part
into
that
and
stuff
like
that,
which
is
kind
of
next
level,
just
kind
of
the
magic
inside
the
module.
How
you
know
when
you
get
the
url,
how
the
backhand
creates
the
content
stream.
A
C
A
At
the
I
can
draw
up
the
the
diagram
this
week
so
that
we
have
it
for
the
for
the
next
community
meeting
as
well,
and
I
can
go
over
it
I'll
publish
it
before
the
community
meeting,
but
we
can
go
over
it.
There.
A
Yeah
you're
welcome
yeah.
I
think,
as
I
mentioned
at
the
end,
I
think,
taking
that
traversing
our
code
can
be
a
little
difficult,
so
taking
that
diagram
along
with
you,
as
you
traverse
the
code,
I
think
will
be
helpful
because
you
can
find
yourself
looking
at
the
generic
interfaces
instead
of
the
concrete
implementations
and
then
it's
sometimes
it's
difficult
to
understand.
A
The
code
tools
won't
like
when
you
control
click
on
something,
or
you
say
like
take
me
to
the
definition.
Some
of
the
tooling
can't
find
the
definition,
because
it's
an
abstract
definition
purely
and
it's
only
ever
concrete
and
the
fact
that
it
satisfies
the
interface
somewhere
so
and
that
can
be
difficult
for
tooling
to
identify.
A
So
I
think
that
diagram
will
help
and
I
I
like,
I
think
milan
is
right
doing
the
next
level
down
of
okay,
here's,
how
printers
take
here's,
how
that
data
from
the
describer
that
lists
the
objects
or
that
fetch
the
object?
How
does
that
then
get
turned
into
that?
Json
that'll
that'll
be
the
next
one.
I'll
do
also
maybe
a
little
deep
dive
into
the
path
filtering
hand,
wavy
magic
stuff,
because
it's
it
works,
but
it's
it's
still
very.
It's
not.
It's
not
super
obvious
how
it
works.
A
A
A
When
you're
looking
at
the
sandbox
view,
so
this
is
reference.dev,
the
sandbox
view
is
literally
a
copy
and
paste
of
our
the.
A
I
think,
one
of
the
namespace
overview
screens
when
you
like
first
spin
up
minicube,
just
as
a
proof
of
concept
that
you
could
copy
and
paste
the
raw
json
into
the
front,
end
components
and
they
would
render
this
is.
This
is
exactly
that,
and
so
this
is
the
kind
of
more
friendly
version
of
it
and
you
can
actually
make
edits
in
here
and
and
see
those
changes
get
realized
on
the
on
the
screen
like.
A
I
think
I
think,
if
I
just
drop
the
s
off,
that
you'll
see
it
says
service
now
I
don't
know
why
the
data
went
away.
We'll
we'll
pretend
that
didn't
happen.
The
data
is
still
there.
A
I
gotta
look
into
that
now
that
bugs
me,
but
yeah
and
all
of
our
components
have
have
that
same.
You
can
you
can
come
in
and
you
can.
You
can
see
like
the
drop
downs
and,
and
you
can
make
changes
to
them
and
and
see
it
directly
in
the
in
the
thing.
So.
E
A
All
right,
that's
so
that's
all
I
have
is
any
other
q
a
or
things
people
wanted
to
talk
about
before
we
call
it.