►
From YouTube: GitHub Quick Reviews
Description
Powered by Restream https://restream.io/
A
All
right,
good
morning,
good
evening,
wherever
you
are
today,
we
are
looking
at
apis
that
we
will
expose
to
make
the
parsing
of
the
release.json
file
that
we
publish
for
our
releases
a
bit
more
friendly
jack.
Do
you
want
to
give
us
an
overview
of
what
this
feature
is
for.
B
So
there's
been
an
ask
from
a
few
customers
that
we've
talked
to
about
how
they
manage
deployments
of.net
core
in
enterprise
and
how
they
get
information
about
what's
available
in
terms
of
updates,
some
of
them
rely
on.
You
know,
looking
at
tweets,
some
run
the
blog
posts,
others
have
written,
simple
applications
that
query
the
releases
json
essentially
look
and
see.
When
updates
become
available.
We
have
internally
used
the
api
recently
to
work
on
an
enterprise
tool
for
msit
cseo
to
figure
out
what's
available.
B
What's
the
latest
release
look
at
what's
installed
and
things
like
that?
That's
mainly
what
we're
using
it
for
and
we
decided
the
api
might
be
useful
for
other
people
that
want
to
write
other
tools
to
query
releases
json,
not
necessarily
to
manage
installs
but
just
to
find
out.
What's
the
latest
release,
is
there
a
security
update?
Perhaps
it's
available
in
some
of
the
releases.
B
I
consider
a
new
sdk
that's
been
deprecated,
has
support
been
added
in
for
an
sdk
runtime
been
added
to
a
specific
version
of
visual
studio
and
things
like
that
and
the
data
also
drives.
I
think
the
net
website
carefully
income
correct
if
I'm
wrong,
but
I
think
like,
if
you
go
to
like
the
download
page,
you
see
everything
that's
driven
by
the
release,
json
data
as
well.
C
The
the
website
is
driven
by
the
data,
and
we
do.
We
have
at
least
two
other
potential
uses
for
this
right
now,
both
in
helping
people
understand
the
global.json
on
their
machine,
which
we
have
a
community
member
working
on,
and
also
we
have
some
internal
ideas
about
acquisition
improvements
we
may
make
in
the
future
where
this
would
be
very
important
to
that,
to
be
able
to
basically
query
your
machine
and
be
able
to
give
you
information
about
whether
you're
up
to
date.
C
So
these
are
some
of
the
ways
that
we
want
this
to
be
used.
We
basically
the
source
of
truth,
is
the
releases.json
file,
and
we
believe
that
this
is
information
that
is
important
to
people,
and
we
want
to
show
that
in
a
way
that
is
a
nice
pretty
api
instead
of
people
having
to
go
download
the
file
and
parse
it
on
their
own,
which
we
think
would
be
a
very
bad
way
to
go
about
this.
A
C
We're
currently,
I
think
we
are
currently
expecting
it
to
be
a
nuget
package,
but
I
don't
think
we
have
totally
closed
on
that
at
this
point
at
this
point
today
we
have
no
use
of
it
in
the
sdk
a
year
from
now
I
may
or
may
not
give
you
the
same
answer
to
that.
It
depends
on
how
we
go
in
a
couple
of
different
directions
and
I
think
until
it
was
needed
by
the
sdk,
we
would
not
put
it
in
the
sdk.
A
A
C
With
yes,
that
is
the
path.
If
we
wind
up
putting
it
into
into.net,
it
would
be
like
a
year
from
now,
so
we
do
have
a
bit
of
time
for
feedback
on
it.
A
Makes
sense-
and
you
already
kind
of
said
this,
but
I
I'm
still
asking
explicitly
yeah
the
the
one
question
I
have
is
so
in
terms
of
consumers.
So
is
the
idea
that
we
don't
have
any
bits
right
now
in
the
box
that
depend
on
it
or
is?
Is
the
idea
that
it's
just
it's
a
public
api?
We
can
use
reason
I'm
asking
here
is
because
I'm
was
wondering
what
dependencies
your
library
has.
I
mean
you
seem
to
depend
on
clearly
adjacent
parser.
I
assume
a
system.
Text.Json
would
be
my
guess.
A
A
B
A
B
The
reason
the
tool
was
was
full
framework
was
because
of
our
dependencies
on
other
assemblies.
We
had
that
did
not
support
core,
though
I
can
totally
see
us
changing
the
tool
to
be
a
self-contained
core
app
and
then
potentially
targeting
something
like
472.
We
can.
We
can
move
to
system
text.json
instead.
A
Yeah,
so
just
one
thing
so
system
text.json
is
available
for
netstandard
2o,
so
you
should
be
able
to
use
it
everywhere.
You
can
currently
including.net
framework
but
like
yeah.
The
reason
I'm
asking
is
because,
depending
on
who
is
using
the
tools,
so,
for
example,
visual
studio
had
has
issues
with
several
people
using
newton's
of
json
and
then
get
everybody
to
agree
on
what
version
of
newton
stop
json
they're
using.
A
So
if
you
are
planning
on
using
this
that
somewhere
in
visual
studio,
for
example,
then
that's
one
thing
to
consider
is
what
dependencies
you're
pulling
in,
but
other
than
that
I
mean
it's
just
fine,
but
I'm
not
trying
to
get
you
to
move
the
system
text.json
for
because
it's
my
feature
but
like
it's
just
one
thing
to
consider.
B
B
We
did
implement
some
features
in
5.0,
where,
if
you're
targeting
end
of
life
runtimes,
the
sdk
will
actually
issue
a
warning
for
you
now
in
five
at
the
moment
that
information
is
static
based
on
what's
currently
considered
end
of
life.
The
idea
was
at
some
point
that
we
would
be
able
to
create
the
releases
json
in
the
future
to
get
the
real
data
of.
What's
actually,
you
know
between,
you
know
500
and
60,
something
else
21,
it's
like
they're
going
to
go.
B
You
know
out
of
support,
then
we
have
to
go.
Make
an
change
to
the
sdk
like
being
able
to
use
the
library
to
query
what's
actively
there.
D
B
Something
that
we're
we're
thinking
of
long
term,
but
we
haven't
figured
out
how
we
want
to
do
that
because
it's
an
online,
it's
potentially
an
online
trip
that
it
has
to
make
to
pull
the
data,
which
means
it.
It
adds
over
into
like
the
bulk
process
and
things
like
that.
So
but
that's
just
another
another
application
for
it.
Potentially.
C
Yeah
we
have.
We
have
two
places
that
we're
still
tied
to
information
about
front
that
ultimately
isn't
releases.json,
but
that
we
hard
code
into
the
sdk.
We
do
that
in
two
places
and
that's
an
important
part
of
our
forward-looking
acquisition
strategy
to
complete
to
snip
those
last
two
things
so
that
we
can
only
update
the
sdk
when
there's
an
sdk
change.
Instead
of
continuing
to
update
the
sdk
based
on
runtime
security
improvements.
C
So
I
guess
that's
a
driver
to
say
keep
an
eye
on
that
on
the
keep
an
eye
on
the
dependencies,
which
is
where
your
question
was
driven
from.
C
So
I
think
that's
a
question
that
that
we
can
come
back
that
jack
and
I
and
mark
can
come
back
to.
C
B
Yeah,
that's
why
I
couldn't
target
standard
two
for
because
enterprises
would
need
to
install
472,
whereas
four
five
is
guaranteed
to
be
included
at
least
and
support
it.
So
that
was.
A
That
is
fair,
so
unless
there
are
more
questions
that
I
would
just
walk
the
apis
top
to
bottom,
that's
usually
the
easiest
way.
I
would
use
the
api
view
tool
because
I
already
have
comments
in
there
and
I'm
bad
with
memory
stuff.
A
I
I
do
not
believe
that
I
share
my
screen.
That
doesn't
mean
that
I
didn't
forget
to
share
my
screen,
but
that's
a
different
problem.
Let
me
try
to
find
the
window
again,
which
is
the
biggest
problem.
A
Yep
perfect
yeah,
so
we
have
comments
in
there
so
that
we
can,
because
some
people,
like
myself,
annotated
the
apis
beforehand,
which
is
only
good,
so
I
didn't
annotate
the
namespace
but
like
I
was
just
trying
to
ask
the
question
like
do
we
think
that's
the
right
namespace
in
general,
because
I
don't
know
what
we
have
in
the
microsoft
deployment
today.
I
don't
think
there
is
much
of
anything
in
there.
A
It
doesn't
strike
me
necessarily
as
bad,
but
it's
you
know
we
generally
prefer
using
existing
namespaces
over
creating
new
namespaces.
So
I
was
wondering,
like
you
already
have
name
spaces
for
the
entire
sdk
tooling
right.
I
don't
know
which
one
it
is
again
but
like
I
think
it
was
microsoft.net
or
something.
B
Yeah
I
mean
the
deployment.
Repo
is
something
that's
that's
taking
on
more
work
around
things
like
acquisition
and
stuff,
and
since
this
is
concerned
with
the
releases
that
seem
to
be
like
the
sort
of
a
logical
place,
I
think.
A
Yeah,
I
mean
there's
nothing
wrong
with
the
name
space.
It's
just
that
you
know.
Usually
you
know
when
we
have
existing
namespaces.
We
try
to
fit
into
the
holes
rather
than
creating
new
ones
right.
So
I
was
just
wondering
like
if
the
rest
of
the
I
don't
know
whether
we
have
any
public
apis
except
for
the
was
it
called
the
project
model
or
whatever.
A
The
thing
is
that
it
was
the
the
dom
for
the
what
is
it
the
the
assets
file
or
something
right
so
yeah
I
don't
know
I
mean,
maybe
that
is
the
right
name
space.
It's
a
if
we
don't
have
a
lot
of
player
art
in
the
space.
It's
probably
fine.
C
We
can
we
can
check
with
john
lefon
about
how
he's
anticipating
that
area
growing
and
if
it
overall
is
a
coherent
set,
and
maybe
get
back
to
you
on
that,
because
I
think
part
of
that
is
some
forward-looking
work.
If
I
understand
some
of
that,
I.
B
I
I
briefly
talked
with
the
nikolai
yesterday
and
it
sounded
like
the
you
mentioned
that
the
repo
is
growing
large
enough,
that
they've
gone
sitting
out
like
having
to
introduce
special
tags
for
all
the
projects
and
stuff
to
manage.
So
from
that,
I
gather
that
there
must
be
some
amount
of
group,
but
how
much
I'm
not.
F
Seem
more
like
a
net
releases
thing
than
a
like
how
releases
in
general
would
work,
so
it
should
have
net
in
the
name
somewhere.
A
It's
a
very
specific
set
of
releases
which
are
ours.
I
mean
there's
a
downside
of
putting.net
in
there
like
that's
the
like
imagine,
we
would
have
put
dot
net
core
in
there.
We
would
regret
this
now
because,
if
you
really
rebranded
the
product
right
and
that's
the
general
problem
with
like
brand
names,
I'm
not
very
young
about
net
either.
It's
just
that.
We
have
used
it
in
other
places
for
better
orders,
mostly
for
worse
probably,
but
like
it's,
it's
just
a
consistency.
Argument
right.
B
The
other
thing
that
concerned
me
was,
if
you
look
at
like
the
the
what's
it
the
dtf
framework,
that
is,
the
managed
wrappers
for
the
native
os
apis
that
deal
with
like
windows,
installer
and
stuff.
That
is
also,
I
think,
under
the
microsoft
deployment
namespace.
I
seem
to
recall.
B
A
B
At
the
moment,
it's
full
framework,
it's
it's
when
it's
only,
but
I
mean
the
the
the
content
in
the
releases
json
is,
is
eventually.
If
you
go
down
to
the
leaf
nodes,
it's
all
the
installable
files,
which
is
like
you
know
the
the
tar
files
you
know
arm.
Everything
would
be
there.
The
files
eventually
that
you
can
get
so
somebody
could
potentially
write
a
tool
and
say
well.
You
can
create
releases
and
download
files
for
you
know
mac
or
for
linux,
because
all
that
information
is
there.
A
B
C
A
All
right,
then,
I
guess
let's
go
into
the
meat,
so
the
so
the
core
type.
So
that's
one
thing
that
I
was
slightly
confused
by.
If
I
just
look
at
the
outline
here
like
you,
have
a
release
and
you
have
an
eye
release-
and
I
think
michael
also
pointed
this
out-
it
is
a
bit
weird
that
you
have
a
release,
type
that
doesn't
implement.
I
release
so
I
mean
my
general
question
is
like
do
you
need
I
release?
A
So
that's
why
we
generally
prefer
abstract
base
types
over
interfaces
if
possible-
and
it
seems
like
this-
is
mostly
a
collection
of
things
that
releases
in
general
share
right
so
like
it
seems
like
it's,
you
know,
unlike
innumerable
or
I
comparable
where
you
know,
once
you
have
the
concept,
it
really
doesn't
change
over
time
versus
this
one.
You
know
I
can
totally
see
you
adding
a
new
property
to
this
thing
over
time.
Right,
like
I,
don't
know
an
end
of.
B
Life
or
something
yeah,
things
do
change
underneath
us
and
the
the
the
naming
has
been
very
difficult
because
of
how
things
are
named
in
the
actual
releases
json.
So
the
release
type
itself
that
encapsulates
a
full
release,
which
constitutes
potentially
multiple
sdks,
multiple
runtimes
for
both
core
runtime
asp.net
and
the
windows
desktop
runtime,
whereas
those
are
sort
of
almost
sub-releases
or
sub-products.
B
If
you
want
so,
the
idea
of
I
released
was
that
if
I
want
to
go
through
all
the
files
that
say
in
a
specific
release-
and
I
want
to
capture
the
runtimes
and
the
sdks,
those
are
the
ones
that
have
files
and
potentially
versions
and
stuff
associated
with
them.
So
a
special
runtime
release,
sdk
release
and
then
windows
desktop
release
are
the
ones
that
implement
the
irelease
interface.
I.
A
B
Yeah,
so
at
the
at
the
root
you
have
the
the
releases
index.json
file,
which
I
believe
the
releases
class
is
the
one
that
has
the
factory
methods
for
downloading
and
instantiating
those
and
then
within
within
the
index.
You
essentially
have
what's
really
a
summary
of
the
of
the
channel
like
say:
net
core
500
or
2
1,
and
it
gives
you
a
short
breakdown
of
like
this
is
when
it's
expected
to
go
end
of
life.
This
is
the
latest
runtime.
B
Then
it
is
sdk
that
was
pushed
contained,
the
security
update
or
didn't,
and
then
that
summary
has
an
additional
url
that
points
to
the
full
json
for
that
specific
channel.
That
covers
everything
that
was
publicly
released
in,
say,
2,
1
or
500
or
30.,
and
then,
once
you
parse
that
you
essentially
get
for
each
time
that
we
do
an
actual
release,
you
get
a
release
which
then
can
have
multiple
sdks
and
runtimes
associated
with
it,
depending
on
so
what
we
decided
to
ship.
B
A
A
You
you
so
because
I
mean
intuitively,
I
would
think
like
if
you
ask
releases
for
get
latest.
You
would
say
probably
at
this
point
you
know
five
volt
preview
or
something
right
but
like
it
seems
like
if
you
want
to
get
the
latest
for
31.
You
just
have
to
get
the
channel
for
31
and
then
ask
that
for
latest
right.
B
A
A
Me
just
hide
the
comments
really
quick,
so
we
can
just
see
the
apis
for
now.
So
this
channel
is
this
guy
here
and
then
that's
the
one
that
you
asked
for
get
latest
and
then
you
go
back
to
release.
A
C
To
pull
this
up
I'll
admit
that
I
know
this
stuff
and
I've
gotten
a
little
bit
lost
on
the
definition
of
these
things
here.
So
we
have
I'm
wondering
if
we
could
get
a
one
sentence.
Definition
of
what,
in
this
context
or
releases
a
channel
is
and
then
there's
a
kind
of
a
level
that
I
have
in
my
head.
That's
not
here,
which
is
not
a
problem.
It's
just
that
I'm
not
yet
relating
to
these
and
I'm
gonna
guess.
Maybe
I'm
going
to
guess.
B
So
a
a
release
is
a
full
net
core
release
that
includes
runtimes
and
sdks,
whether
it's
servicing
or
security
doesn't
really
matter,
but
it's
a
full
product
release
of
everything
like
it's
a
coherent
world.
Essentially,
you
can
think
of
it
in
that.
In
that
context,
that
release
is
associated
with
a
specific
channel,
which
has
a
major
minor
version
and
a
channel
describes
essentially
all
the
releases
from
day
one
to
where
we
are
today.
A
So
I
don't
know:
how
much
are
you
attached
to
the
naming
convention
that
is
in
the
json
file
versus
what
you
want
in
your
apis,
because
my
personal
viewpoint
is:
there's
always
some
value
in
the
line
in
them,
but
very
often
the
civilization
format
is
impossible
to
change.
So
whatever
naming
you
have
is
the
naming
you
currently
have
and
that's
not
going
to
change.
So,
like
my
question
is,
can
we
rename
things
here
in
the
api
service
or
would
you
you
know
flip
a
table
when
we
do
that.
B
Everything
that
I've
seen
seems
to
be
just
the
major
minor
in
terms
of
like,
for
the
most
part,
usually
on
the
run
times
or
how
we
brand
the
the
release
like
when
we
talk
about
like.net,
500
or
three
one.
There
is
an
sdk
associated
with
what
we
might
consider
to
be
the
latest
release,
but
there's
also
runtime
and
we've
been,
unfortunately
inconsistent
with
individual
releases,
how
we
pivot,
because
sometimes
we
we
use
the
sdk
version
for
a
release.
B
C
C
I
think
we
can
potentially
nail
down
an
exact
meaning
for
the
for
release,
because
it
is
an
action
and
a
set
of
things,
but
I
would
like
there
to
be
as
few
as
words
as
possible
that
are
that
you
start
with
having
a
naive
person
starts
with
having
almost
no
relationship
with
with
the
words.
C
So
I
you
know
I'm
thinking
naive.
What
would
my
words
be
and
feature
set
means
something
different
to
us,
but
you
know.
The
thing
I
want
is
ultimately,
though,
this
is
a
super
important
concept
for
somebody
using
this,
because,
ultimately,
that's
the
thing
you
want,
and
so
what
words
anybody
who
has
any
ideas
for
these
words
would
be
greatly
appreciated,
because
what
I
want
is
obviously
not
the
right
name
for
this.
For
this
field.
C
B
A
So
I
think
the
yeah,
I
think
part
of
the
problem
here
is
you
use,
release
pretty
much
everywhere
right
so
like
it
becomes
very
overloaded.
I
think
the
I
mean
I
would
say
like
if,
if
you
use
release
as
a
as
a
as
a
as
a
word,
you
combine
others
with.
I
think
it's
fine,
for
example,
release
file
release
index
seems
largely
fine,
but
if
you
do
something
like
you
know,
product
like
release
channel,
for
example,
I
think
is
because
of
the
word
channel
is
a
bit
ambiguous.
I
would
probably
choose
something
else.
A
Like
I
don't
know,
maybe
band
is
better
release
group
that.
D
F
Preview
like
like
it's,
which
it's
sort
of
which
place,
are
you
looking
to
get
releases
yeah.
A
That's
it,
that's
why
I
feel,
like
you
know,
bands
or
group,
or
something
to
that
extent,
makes
more
sense,
because
you
would
want
to
convey
this
as
a
different
version
of
the
product
right,
not
a
you
know,
a
different
like
source,
where
you
got
the
bits
from
or
a
different
quality
level.
I
guess
is
the
way
to
say
that
generally
implies
quality
levels
versus
this
band
would
just
require
you
know,
but
it
would
imply
like
a
feature
set.
H
B
F
C
H
B
I
would
say
yes
and
though
there
are
cases
where
you
would
care
about
it,
but
when
you
start
looking
at
the
sdks,
you
likely
want
to
care
about
the
feature
bands,
because
the
feature
bands
in
the
sdks
at
least
implies
some
amount
of
compatibility
right.
So
something
like
two
one,
six,
hundreds
there's
just
things
associated
like
support
and
visuals
and
certain
versions
of
visual
studio,
while
you
know
2.8,
is
maybe
not
supported
or
g1700.
A
Right
I
mean,
let's
table
the
feature
bands
for
a
moment,
because
that's
another
level
of
complexity.
I
mean,
let's
just
start
with
the
above
the
big
thing
at
the
at
the
very
top.
So
basically
the
your
entry
point
is
releases
right
now
right.
So
the
one
thing
I
would
say
is:
plural
names
are
not
great.
If
you
also
have
the
singular
name,
because
then
it's
just
very
subtle
in
the
api
of
release
versus
releases.
A
I
don't
know
exactly
what
you
would
rename
it
into,
but
the
other
thing
I
don't
understand,
oh
yeah,
because
you
yeah,
because
it's
a
bit
weird
I
mean,
if
it
just
will
be
aesthetic
type.
It
also
wouldn't
be
too
bad,
but
you
actually
return
instances
right,
so
you
basically
say
create
it
from
default
url.
Then
you
return
release
sys,
which
is
a
bit
odd.
A
I
guess
in
your
world,
if
you
actually
call
it
release
collection
that
wouldn't
be
terrible,
but
then,
if
you
enumerate
that
you
better
have
individual
things
called
release
right,
because
the
release
collection
really
should
be.
You
know
a
list
of
releases
which,
in
your
world
I
don't
think,
would
be
the
case
right
so,
like
your
releases
doesn't
really
have
that
it
has
a
collection
of
channels
realistically
right.
E
B
Then
I
thought
like
what
do
I
call
do?
I
then
stick
with
the
release
index,
which
I
still
have
for
like
the
individual,
like
a
single
like
this,
that's
sort
of
like
almost
like
a
a
product
line
summary
if
you
want
to
stick
with
that
with
that
notion,
that's
essentially
what
it
is,
because
it
just
gives
you
a
summary
of.
A
A
A
Maybe
so
I
mean
like
I
guess,
if
we
I
mean
one
thing
we
could
say
we
could
just
say
you
know
the
major
minor
version
we
just
designated.
That's
the
product
all
right.
Let
me
just
say:
net
core
1011
are
just
different
products
right
and
then
we
could
just
say:
okay,
it's
realistically
what
this
releases
for
it
gives
you
access
to
is
the
products
right.
H
One
release
can
have
multiple
channels
here.
How
does
that
play
out?
What
does
that
look
like
in
the
file.
H
B
Yes,
yeah:
it's
essentially
the
releases
index
that
url,
where
I
placed
in
the
I
am
that's
where
it
starts,
and
then
it
will
parse
each
of
the
the
index
entries
grab
the
json
for
that
and
then
deserialize
that
whole
set
of
releases
for
that
channel,
and
then
you
can
basically
query
it
from
this.
This
the
universe
releases.
A
All
right
see
now
understand,
so
reason.json
is
basically
just
a
file
that
points
to
the
json
file
per
product
version
effectively
yeah,
okay,
that
makes
sense,
but
that's
kind
of
an
implementation
detail
of
how
the
stuff
works
right.
That's
just
the
mental
model
that
we
want
to
have
so
then.
A
Maybe
you
want
even
a
custom
collection
if
you
want
custom
indexers,
for
example,
right
because
then
you
don't
have
to
do
things
like
you
know,
have
the
indexer
on
the
releases
take
the
channel
version.
It
might
make
more
sense
to
just
say
you
know,
channels,
bracket,
channel
version,
right
that
seems
more
natural
than
exploding.
These
things
out.
F
And
on
properties
effectively,
you
should
never
return
an
interface,
especially
for
enumerable
things,
so
it
this
should
be
read
only
collection
or
list
or
a
custom
collection
type,
and
it's
because
whatever
it's
returning
someone's
going
to
cast
it
you're
never
allowed
to
change
it.
So
just
be
honest
with
what
it
is
at
the
beginning,
that's
yeah
the
the
short
summary
of
how
we
get
there.
A
So
that's
why
yeah,
probably
you
should
store
them
in
something
that
is
like
a
you
know,
an
array,
that's
fine,
but
then
keep
in
mind
that
if
you
expose
it
like,
if
you
literally
just
return
underscore,
you
know
channels
which
is
a
field
of
type
array,
somebody
can
just
cast
you
or
immobile
away
into
an
array
right.
So
one
thing
we
do
often
when
you
don't.
A
If
you
look
at
how
our
collection
types
work,
we
have
these
object
model
name
space
where
you
have
things
like
collection
of
tea
and
read
only
collection
of
tea,
and
so
what
you
do
is
you
construct
one
of
them
and
you
pass
in
the
underlying
data,
and
so
then
the
consumer
of
this
collection
thing.
They
can't
cast
it
away
right
because
the
the
actual
data
is
effectively
an
internal
field
of
this
type
right,
and
so
you
have
more
control
over
your
data.
A
People
can't
just
cast
it
away
and
then
you
know
store
data
in
the
array
which
you
may
think
is
crazy,
but
the
reality
is
people
do
civilization
all
the
time
and
then
they
end
up
accidentally,
depending
on
the
actual
runtime
type
that
you
exposed
it
under
right,
not
the
actual
thing
you
typed
it
under,
and
so
that's
one
thing
to
keep
in
mind
so
long
story
short.
I
would
probably
have
a
custom
type,
like
I
don't
know,
probably
not
channel
collection
but
like
product
collection.
A
That
is,
you
know,
deriving
from
type,
let's
say:
read-only
collection
of
product
right
and
then
you
have
your
own
custom
index.
So
that
takes
a
channel
version
and
then
gives
you
back
a
product.
I
guess
right.
B
Index,
so
that
is
like
a
single
entry
that
describes
a
specific
channel
like
it's
it's
it's
sort
of
like
a
summary
of.
What's
a
channel
today,.
A
B
It
repeats
it
repeats
in
the
channel,
but
it
gives
you
an
a
quick
overview
if
you're
working
through
all
the
through
the
index
itself,
some
of
the
data.
A
B
Yeah,
it
is
a
single
summary,
so
it
has
no
information
about
individual
products.
It
just
has
a
summary
of
like
what
the
current
state
of
the
channel
it's
it's
almost
like
a
channel
state
in
in
some
ways
or
against
a
channel
summary
or
a
product
line
summary
because
it
literally
just
says
like
this
is
the
version
of
the
channel.
This
is
the
latest
release.
It's
end
of
life.
A
A
You
would
just
have
it
on
the
same
type
and
then
some
data
might
be
lazily
loaded
and
some
data
might
not
be
right
and
so
the
it
seems
a
bit
weird
to
ask
you
consumers
to
look
in
different
places,
because
then
you
have
to
like,
if
you're
standing
on
a
channel,
how
do
I
get
the
corresponding
index
right,
like
it's
a
lot
of
work
versus
if
I'm
standing
on
the
product?
Well,
then,
you
know
it's
property,
a
b
and
c
and
then
c
might
require
more
data
to
load.
But
a
and
b
does
not
right.
F
B
Is
more
aggressive,
the
other
ones
will
use
a
local
copy
unless
you
tell
it
to
go
online
and
check
for
a
new
one,
which
is
the
the
I
think,
the
third
one,
the
one
with
the
the
used
latest,
which,
if
you
don't
want
to
go
online,
to
see
if
there's
a
new
releases
which.
H
F
It
is,
it
is
not
lazy
at
this
point.
Okay
yeah,
I
mean
one
point
that
we
skipped
over
is
all
of
these
things
need
async
versions.
If
you
touch
the
network
or
a
file,
you
should
also
have
an
async
version.
Yes,
and
if
it's
aggressive
at
the
entry
point,
then
you
only
need
async
entry
points
and
everything
else
is
just
data
which
is
happy,
but
we're
currently
missing
that
okay,
so
there.
So
when
you
create
one
of
these
things,
it
will
open
in
plus
one
files
where
n
is.
I
I
H
Yeah
I
mean
I
I
think,
do
we
want
to
very
closely
resemble
the
file
format,
or
would
we
like
it
to
be
a
more
like
idiomatic
object,
structure
that
happens
to
serialize
to
a
certain
format.
A
I
mean
my
personal
opinion
is:
if
you
wanted
to
be
a
successful
api,
I
would
not
merit
of
the
underlying
json
file,
because
it's
it's
usually
cumbersome
right
and
it's
usually
not
like
I
mean
you
can
do
some
interesting
tricks
in
the
file
where
you
split
things
across
different
file
boundaries
to
avoid
hitting
things
but
like
in
the
object
model.
You
model
these
things
usually
differently
right.
A
You
would,
as
I
said
like
instead
of
having
like
you
know,
channel
and
index,
you
would
have
some
properties
off
of
channel
or
even
a
method
on
channel
that
allows
you
to
fetch
the
other
data
and,
and
that
might
be
way
more
useful
and
easier
to
use
than
you
know,
a
secondary
top
level
entry
where
you
now
have
to
map
them
back
and
forth
right
and
then,
once
you
do
things
like
this,
usually
the
my
experience
is:
if
you
try
to
keep
to
align
the
naming
it
usually,
you
know,
doesn't
work
anymore,
because
you
know
the
the
concept
you
call
the
release
and
the
file
format
might
be
split
across
four
files
versus
in
the
object
model.
A
It
might
be
just
one
and
then
it
might
be
more
confusing
than
anything
else
if
you
try
to
artificially
try
to
make
them
the
same.
So
I
would
just
say
treat
this
api
as
an
abstraction
over
the
file
format
and
then
yeah.
If
somebody
wants
to
go
party
on
the
file
format
themselves
more
power
to
them,
but
then
they
have
to
read
the
file
format
and
deal
with
what
naming
that
one
has
right,
and
I
would
just
keep
the
api
here.
It's
just
really
convenient
and
you
know
simple
to
use.
H
Yeah
I
mean
looking
at
the
files
it
looks
like
this.
Could
almost
this
is
a
very
pretty
simple
hierarchy
here
we
have
channels,
and
each
channel
has
one
or
more
releases
right,
so
I'm
not
sure
how
much
kind
of
duplicating
data
or
summarizing
it
is
going
to
get
here
unless
our
goal
is
maybe
reducing
io
for
a
user
who
who
may
not
need
the
detailed
information.
A
I
mean
that's
my
other
question
I
have
is
like
you
know,
you
know,
I
didn't
really
listen
to
the
answer
to
what
jeremy
said
but,
like
you
know,
basically,
when
you
go
to
the
entry
point
create
from
file,
even
though
this
thing
is
super
eagerly
and
it
loads
everything
I
mean
we
talked
still
about,
like
you
know,
a
couple
hundred
k,
jason
right
so
like
that
that
would
be
you
know,
on
modern
computers
and
the
orders
of
still
have
milliseconds
right.
A
B
Yeah
I
mean
the
for
the
amount
of
data
it
probably
doesn't,
because
the
files
are
are
usually
very,
very
small.
A
I
mean
I
mean
it
kind
of
depends
on
your
scenario
right.
If
I
run
this
tool
once
a
day
to
fetch
updates
it
pretty
much
can
be
as
slow
as
I
want
right
but
like.
But
if
I
do
this
in
a
hot
loop
somewhere,
then
it
might
matter
right,
but
this
doesn't
strike
me
as
something
that
you
would
ever
run
in
a
hot
loop
anywhere
right
like
it
seems.
A
I
mean
I
I
hear
what
you're
saying,
but
let's
go
with
10
years
in
the
future
right,
so
we
ship
now
once
a
year
right.
So
that
said
it's
10
years
and
then
effectively
you
have,
I
don't
know
like
let's
say,
10
20
releases
a
year
or
something
like
how
big
is
this
json
file
right?
That's
still
going
to
be
less
than
a
megabyte,
probably.
I
I
A
H
B
I'm
assuming
that
they
know
what
the
releases
that
they
want.
I
would
say:
yes,
the
the
other
thing
that
the
index
sort
of
gives
is
it's
the
the
one
source
of
truth
to
say
like
these?
Are
the
official
release
channels
or
product
lines?
What
we
want
to
call
them
so
like
if
you,
if
you
ask
for
like
the
3.2,
it's
obviously
going
to
be
there
because
nothing
is
defined
for
3.2.
A
But
conceptually
you
could
just
parse
the
root
json
file
right
and
that
presumably
has
metadata
of
what
channels
exist
right,
correct
and
so
the
idea
would
be.
If
I
just
do
the
create
from
you,
just
pass
the
root
json
file,
and
then
I
guess
in
your
world.
If
I
just
query
the
index
property,
you
wouldn't
have
to
fetch
anything
else.
But
if
I
were
to
create
the
channels
thing
now,
you
have
to
fetch
all
the
channels.
In
order
for
giving
me
to
give
me,
the
actual
channel
data
is
that
fair.
A
Yes,
so
then
I
kind
of
agree
with
course,
and
it
would
make
sense
to
me
to
say
we
have
some
sort
of
type
that
represents
the
metadata
in
that
json
file,
which
in
your
world
right
now
is
the
index.
I
think
release
index
and
I
would
still
call
this
probably
product
or
something,
and
then
you
know
the
actual
heavyweight
data
that
allows
you
to
that
you
need
to
in
order
to
fetch
more
data.
A
You
call
really
product
details
that
say,
and
then
you
have
an
async
method
on
product
that
fetches,
that
if
you
want
this
way,
basically,
when
I
just
say
create
from
I
just
get
the
fast
metadata,
I
can
it
I
can
iterate
over
them.
I
can
find
the
one
that
I'm
interested
in
and
then
I
can
say
on
that
guy
okay,
now
go
fetch
the
details.
B
F
F
It's
probably
never
going
to
be
all
that
big
really,
so
I
don't
know
that
I
would
do
async
innumerable
I'd,
probably
just
make
it
be.
You
know,
task
of
channel
collection,
sure
and.
H
F
F
C
F
F
I
guess
the
summary
also
would
tell
you
the
oh
I'm
I'm
already
on.
I
said
three
one
3.1.8,
so
I'm
up
I'm
good.
I
don't
need
to
go.
Ask
any
more
information.
A
The
other
thing
I
would
do
is,
I
would
use
async.
I
think
you
don't
use
async
apis
anywhere.
I
would.
I
would
make
it
very
clear
where
the
boundaries
are,
where
you
fetch
data
from
the
network
by
basically
using
you
know,
task
of
whatever
you
return
right
so,
for
example,
create
from
should
return
a
task
of
whatever
the
thing
is
that
it
returns,
because
basically
that
also
makes
it
clear
for
the
user.
What
are
the
expensive
operations
right
right
now,
when
I
would
just
dot
into
the
channels
thing?
A
Well,
then
you
magically
do
an
io
request
behind
my
back
and
that
might
block
now
right.
So
it
seems
for
me
from
an
api
standpoint
like
on
one
hand
side
like.
I
think
I
like
what
jeremy
just
said
is
like
the
the
yeah.
The
general
problem
is
you
want
to
know
when
you
actually
hit
the
wire
right
and
it
right
now
it's
hard,
because
you
just
dot
into
the
channels
thing,
and
then
you
know
some
io
happens.
I
like
the
abstraction,
in
the
sense
that
you
don't
give
me
these.
A
You
know,
grab
back
of
individual
items
like
channels
and
index.
So
I
think,
like
just
making
the
naming
a
bit
more
consistent
and,
like
you
know,
moving
these
async
methods
to
the
actual
objects
from
which
you
fetch
them
is
nicer
for
the
user,
but
you
still
understand
where
the
expensive
part
of
the
enumeration
come
right.
You're,
not
surprised
that
if
I
do
a
for
each
loop
and
then
for
each,
you
know
either
my
effect,
you
know
fetch
more
data.
You
know
the
code
looks
as
expensive
as
it
is
right
it
doesn't.
B
Yeah,
and
especially
like
on
the
I'm
jumping
a
little
bit
ahead,
but
under
on
the
release
file,
for
example,
like
that's
the
guy
that
has
like
an
individual
url,
the
actual
right
that
you
can
download
like
that,
I
mean
I.
I
have
a
utility
message
there
for
download,
but
I
I
would
imagine
like
that.
You
would
really
want
something
like
download
ac,
because
it's
potentially
going
and
fetching
like
a
few
hundred
mics.
F
A
Yeah,
I
guess
in
your
case
that's
an
it's
an
interesting
point
right
so
because
you're
servicing
the
firmware
customer
base
and
the
problem
that
I
mean
it's
not
so
much
that
dot
customers
are
less
sophisticated.
It's
just
a
function
of
existing
code
right.
The
problem
is
async
is
viral,
so
the
azure
sdk
found
this
out
the
hard
way
they
did
everything
nicely
async.
A
A
So
don't
do
properties
that
do
I
owe
right,
that's
the
big
one,
all
right
so
like
I
think
we
gave
you
a
lot
to
think
about
like
it's
it's
hard
for
me
in
my
head
now
to
to
mirror
this,
but
like
I
guess
you
probably
have
to
another
iteration
on
this
anyway.
So
I
I
kind
of
wrote
down
the
notes
of
what
the
rough
thing
is.
We
said
so
then,
okay
formal
release.
Now
where
should
we
go
index
or
channel?
I
B
So
the
idea
there
was
like
especially
like
in
the
context
of
the
tool
that
I
have
today,
is
it
like.
It
writes
a
bunch
of
data
like
to
the
user
stamp
folder,
so
it
will
bring
down
the
releases
station
there.
B
It
will
do
typically
like
if
you
do
like
create
from
file.
It
will
automatically
look
for
the
latest
to
see
if
there's
a
latest
one,
so
it
like
does
a
head
request
figures
out.
If
it's
not
a
newer
one,
it
doesn't
download
anything.
It
just
takes
the
data,
that's
on
disk
and
it
parses
that
and
deserializes
that
that
json.
B
Otherwise,
if
there
is
a
later
version
available
online,
it
will
go
and
fetch
those
and
bring
those
down
we
use
latest
to
disable
it.
I
should
probably
be
more
internal
because
I
because
the
json
is
large,
I
actually
have
collections
of
just
the
little
the
raw
files,
a
specific
version
that
I'm
using
for
for,
like
some
of
the
unit
tests
and
stuff
sort
of
merge
real
data,
because
there's
supposed
to
be
there's
been
some
issues
in
the
actual
data.
That's
live
that
are
inconsistent,
so
I
found
for
the
unit
test.
B
If
I
can
just
use
like
a
static
set
and
never
go
and
like
accidentally
like
bring
down
a
bunch
of
new
data,
because
in
my
unit,
as
well
as
to
change
underneath
me
as
things
go
out
the
door,
so
that
can
probably
just
be
like
an
internal.
B
B
A
B
A
H
A
A
A
So
the
only
reason
why
you
may
want
a
version
type
is
if
people
were
ever
likely
wanting
to
compare
them,
because
if
people
use
string
comparisons,
they
all
work
as
great
until
we
ship
dot
net
11,
why
even
10,
yeah
and
then
bad
things
will
happen
if
you
think
they
only
ever
use
that
to
just
print
something
on
the
screen
or
allow
people
to
select
stuff.
But
you
only
ever
need
identity,
then
string
is
fine.
B
I
have
not
seen
that,
but
I
can
see
that
if,
if
you
grab
like
the
index
and
you
want
to
like
I
mean
I
have
like
a
one
of
the
things,
I
I
wrote
with
the
with
the
tools
is,
there
was
like
a
query
interface
for
the
releases
json,
which
that's
simple
command
line
options
and
it
basically,
if
you
create
like
the
index,
it
just
dumped
everything
in
order,
but
I
can
definitely
see
somebody
like
taking
that
information
and
trying
to
like.
You
know
order
by
the
the
channel
version.
A
A
Because
if
the
only
thing
you
actually
do
is
effectively
just
search
a
particular
thing,
maybe
it
shouldn't
be
version,
but
name,
and
then
you
just
return
it
to
what
I
just
said.net
core31.net
five
and
then
you
can
just
look
for
those.
But
if
you
actually
need
to
say
well,
I'm
on
version
x,
what
is
the
next
big
thing
I
can
upgrade
to
then
you
kind
of
want
comparison
at
that
point,
you
probably
want
the
version.
B
So
the
product
version
is
actually
a
semver
implementation.
Well,
we
talked
about
this
previously
right.
It's
actually
assembler,
but
there's
two
additional
things
because
one.net
uses
the
assembler
format,
but
it
doesn't
follow
the
spirit
of
semver
and
there
is
also
the
concept
of
for
the
sdks
at
least
feature
bands
and
patch
levels,
which
is
a
sub
interpretation
of
like
the
the
patch
number
and
things
like
that.
So
that's.
G
A
A
So
that's
unfortunate,
because
if
we
rename
release
channel
to
product
then
product
version
is
actually
the
version
of
the
release,
not
the
product.
So
so
we
probably,
I
will
probably
rename
just
product
version
to
release
version,
because
it's
always
a
version
of
a
release,
not
a
version
of
the
product.
F
A
Yeah
so
like
to
me,
it
seems,
like
your
channel
version
is
really
more
of
a
name
of
that
product,
except
without
the
naming,
but
like
it
may
be
worthwhile
to
just
have
you
know?
Maybe
you
just
have
version
as
a
string,
and
then
you
just
have
name
that
is
the
actual
display
name
or
you
just
have
display
name
yeah
this
by
name.
It
probably
makes
more
sense.
A
A
A
B
Yeah,
so
release
channel
is
potentially
like
it
would
parse
the
link
that
I
just
sent
to
be
like
for
a
specific
okay.
A
F
Right
but
depending
on
like,
if
you
allowed
these
to
be
built
from
a
url
directly
then
you'd
have
to,
I
guess,
take
it
as
a
parameter
of
like.
And
what
did
you
think
this
product
was
called
so
yeah
because
you're
you're,
depending
on
data
that
is
not
self-contained
and
what
it's
trying
to
represent.
I
D
So
you
want
to
add
a
in
essence:
the
the
product
name
into
the
releases
json
as
well.
I
D
No,
the
the
data
for
a
given
release
is
derived
from
the
the
entire
product
as
it's
staged,
and
so
there's
there's.
Obviously
some
version
information
that
comes
out
of
the
build-
and
we
just
finished
in
the
process
of
finishing,
at
least
on
the
5-0
side
of
the
world,
tooling,
that
will
drive
all
of
the
the
diversion
goo
from
the
actual
build
drop
on
the
on
the
servicing.
So
three
one
two
one:
it's
it's
manually
checked
in
config
files
that
are
then
used
to
generate.
I
I
had
a
minor
comment
about
the
support
phase.
If
that's
a
static
list
of
known
types,
if
that
could
be
an
enum
seems
like
that,
would
help
the
usability.
B
I
originally
had
an
enum
project,
but
then
the
list
changed
when
we
shipped
rc.
Originally,
when
I
looked
at
the
data,
we
had
basically
end-of-life
maintenance,
which
was
a
inconsistency
that
still
exists.
I
think
in
the
2-2
channel,
which
is
essential
end-of-life
then
we
had
lts
and
we
had
preview
and
then
when
fiverr
rc,
slipped
rc
suddenly
appeared
in
the
index
and
it
threw
me-
and
I
I
switched
to
like
a
freeform
string.
D
C
Lee
can
we
come
up
with
a
finite
list
that
doesn't
have
to
just
be
previewed,
but
can
be
whatever
we
decide
with
management.
But
if
we
do
lock
the
if
we
wind
up
locking
down
a
list,
it's
going
to
be
pretty
baked
into
the
api.
So
we
may.
D
D
Yeah,
I
think
the
list
we
have
now
with
the
addition
of
rc
feels
like
something
that
we
could
could
sell
to.
You
know
hunter
and
company
without
a
whole
lot
of
difficulty.
I
C
Then
we
may
wind
up
with
a
separate
value
for
what's
actually
in
releases
dot
json,
which
may
be
a
broader
set.
But
if
we
add
a
new
value,
however,
we
do
it.
If
we
had
a
new
value
and
somebody's
logic
is
dependent
on
the
preview
things
being
x,
y
and
z
and
all
of
a
sudden
they're
x,
y
z
and
z,
prime
then
their
logic
will
be
broken
just
because
we
added
a
new
value.
So
I
think
we
want
to
be.
D
F
An
enum
it
needs
to
have
an
un
unknown
value
of
you
couldn't
parse
it,
but
with
an
enum
you
do
need
to
be
careful,
and
essentially
you
need
to
do
it,
like
you
know,
old,
basic
of
don't
give
them
adjacent
numbers
because
someone's
going
to,
if
you
start
out
with
it,
looking
like
you
know,
daily
preview,
rc.
D
F
You'd,
have
you
know
unknown
at
zero,
and
then
you
know,
let's
say
we
skip
by
a
hundred
and
then
always
bisect
whenever
we're
inserting
a
new
thing
and
then
yeah
you'll
end
up
with
an
unknown
at
some
point
when
we
defined
experimental.
F
A
Yeah-
and
I
think
that's
that's-
probably
what
I
would
do
because
quite
frankly
like
if
you
do
string
based
things,
it's
I
think
string
based
is
useful
when
you
have
an
object
model
that
has
to
round
trip
right.
So
if
you
have
to
be
able
to
load
the
json
file
and
then
write
it
back
at
that
point,
you
want
to
be
able
to
to
hold
the
value
at
full
fidelity,
in
which
case
the
string
makes
more
sense.
But
in
your
case
you
map
it
only
one
way,
and
so
you
you
can
either
decide.
A
You
only
expose
three
of
the
20
items
in
the
json
file.
You
just
have
a
mapping
function
or
you
can
decide
you
always
map
it
one
to
one,
and
then
you
have
to
have
an
enum
member
for
every
single
thing
that
occurs
and
then
everything
you
don't
know
you
just
throw.
That's.
Also
fine,
like
I
think
that's
you
know
just
make
an
actionable
error
message,
like
you
know,
unknown
data
in
json
file.
Please
upgrade
your
library
and
that's
the
end
of
that,
which
still
seems
fine.
A
H
B
D
F
D
A
A
I
was
about
to
say
that
so
the
problem
with
that
kind
of
thinking
is,
it
makes
sense
at
a
high
level.
I
I
just
don't
think
you
can
take
these
labels
and
boil
them
down
into
policies
that
will
actually
be
uniform
over
time,
because
our
management
will
react
to
customer
requests
and
then
in
net
six
we
may
say
that
you
know,
for
whatever
reason,
preview
seven
starts
to
be
go
live
and
then
we
named
it
preview
because
that's
just
the
way
things
are,
and
then
your
code
is
a
hard
time.
Reacting
to
this.
H
Well,
that's
exactly
what
I'm
saying
instead
of
having
this
be
an
enum
that
people
will
make
assumptions
off
of
maybe
a
string
is
better
because
it's
specifically
saying
that
hey
this
can
be
anything
useful.
Well,
the
problem.
A
A
Yeah,
I
think
the
only
problem
I
have
with
that
is
that
now
you're
going
out
of
your
way
to
not
say
the
what
is
the
actual
qualifier
right.
But
then
you
go
to
our
block
and
it
says
you
push
preview,
seven
and
now
you're
trying
to
find
preview
somewhere
in
the
in
the
list,
and
you
can't
find
it
and
now
you
have
to
do
the
reverse
mapping
right.
So
I
think
that's.
A
I
think.
If
the
only
thing
you
would
do
is
programmatic
access,
I
would
agree
with
you,
but
given
that
people
will
have
to
map
these
values
to
something
that
they
read
somewhere,
that
seems
a
bit
backwards,
but
I
mean
that's
the
other
question
like
how
do
we?
How
do
I
get
previous
six
versus
preview?
Seven?
Are
these
different
labels
or
is
it
just.
B
A
B
It's
just
a
version,
that's
in
associated
with
the
release
that
says
this
is
that
happens
to
contain
the
word
preview
in
it,
particularly
in
rc
or
whatever
other
method.
Yeah.
F
D
D
Yeah,
it's
it's.
The
policy.
A
F
A
D
F
A
B
That's
what
the
latest
release
does
they
did
they
get
latest
release
gets
you
that
that
gives
you
information
about.
If
you.
F
F
B
C
B
So
if
you
take
the
latest
sdk,
which
I
should
really
say,
there's
sdk
version,
I
guess
from
the
the
version
you
can
actually
extract
the
feature
and
the
patch
like
product
version,
has
properties
for
feature
band
and
patch
level.
E
A
C
Yeah,
I
think
this
shows-
I
think
this
shows
the
history
of
this,
which
is
basically
that
we
had
a
need
for
it
for
this
cseo
tool
and
as
soon
as
I
heard
about
it,
I
said,
hippie
and
other
people
definitely
have
fun
and
some
other
people
as
well
said
yippee.
We
need
to
make
this
public
api
and
I
don't
think
we
sat
down
and
invested
with
jack,
who
was
working
on
the
cseo
tool
and
and
really
thinking.
C
This
is
a
great
depth
and,
to
be
honest,
I
think
we
could
use
some
help
with
that
to
to
get
that
right.
So
if
anybody
wants
to
wants
to
volunteer
at
a
meeting
to
go
deeper
into
some
of
these
things,
that
is
attuned
to
the
way
we
do
apis
here.
That
would
be
appreciated
from
my
point
of
view
and
we
might
bring
dan
in
as
well
who's
got
an
interest
in
this.
C
I
I
think
it
I
I
think
it's
worth
getting
this
right
and
I
think
we've
the
natural
way
for
jack
to
solve
the
problems
that
he
had
was
to
come
from.
The
point
of
the.
D
C
The
json
file-
and
I
believe
that
between
the
lines
under
what
we're
seeing
today,
is
that
maybe
this
api
should
reflect
the
questions.
People
are
going
to
ask
and
how
those
questions
are
going
to
get
answered
and
that,
eventually,
within
the
api,
you're
going
to
be
able
to
get
to
all
this
information,
but
that
maybe
it's
not
just
a
wrapper
for
the
index,
but
but
a
way
to
ask
questions
of
our
source
of
truth.
And
so
I
think
that
that
is
a
bit.
Is
it's
gonna
change,
a
few
things
in
the
api
yeah.
B
I
mean
I've
already
run
into
some
of
those
issues
where,
just
because
of
how
the
data
is
structured.
Where
I
I
look
at
a
specific
sdk
and
I'm
digging
deep
into
the
sdk
and
at
one
point
I
sort
of
want
to
say
well,
I
actually
want
to
go
back
to
the
top
level
of
the
release
that
has
this
sdk,
because
I
want
to
find
something
related
into
like
the
asp.net
core
or
the
windows
desktop
runtime
and
because.
D
C
If
we
can,
you
know,
jar
can
use
this
as
it
is
for
the
cseo
tool,
which
has
the
immediate
need,
and
we
have
a
little
bit
of
breathing
room,
not
boat
loads,
because
there
are
some
things
that
I
would
do
with
this
nearly
immediately
if
it
was
if
it
was
ready,
but
I
think
that
taking
a
step
back
and
looking
at
how
the
questions
might
get
answered,
and
possibly
even
bringing
in
the
community
members
interested
in
the
global.json
question,
although
I
could
talked
him
into
being
interested
so
we'll
see,
if
he's
actually
truly
interested
or
just
was
convinced
to
be
interested,
and
so
we
I,
I
think,
I
think,
a
deeper
thinking
of
this.
C
Yeah,
and-
and
we
do-
I
mean
we
have
the
others-
we
have
the
others
we're
beginning
to
understand.
So
the
the
goal
that
jason
questions.
We
know
the
simple
things
that
we
want
from
that
and
what
we
think
we
need
for
acquisition,
we're
going
to
very
soon
have
an
idea
of
what
we
think
we'll
want
for
that.
We
know
what
we
need
for
the
two
cases
of
snipping,
the
runtime
and
sdk.
So
these
other
things
that
are
in
the
that
are
out
there.
C
C
Table-
and
I
I
guess
with
that-
you
all
are
going
to
have
to
give
feedback
as
to
how
much
what
is
most
useful
right
now,
except
that
you
know
we
kind
of
need
to
step
back,
which
is
the
way
I'm
kind
of
feeling.
Based
on
this
conversation,
and
I
I
don't
know
how
much
more
detail
it's
worth
going
into
right
now,.
C
And
I
would
really
like
it
if
there
was
somebody
that
doesn't
necessarily
have
to
be
involved
in
the
whole
process,
but
before
we
come
back
to
this
size
of
a
group,
getting
some
feedback
along
the
way
on
on
this
on
expressing
this
problem
would
be
great.
A
Yeah
I
mean
like
I
I
would
what
I
would
do
is
like
I
mean
we,
you
know
have
30
minutes
left
so
like
I
would
I
would
do
is
I
would
go
with
the
mainline
types
and
the
mainland
relationships
and
then
once
jack
has
another
drop
of
that.
Where
that
feedback
is
addressed,
we
do
another
pass
over
it.
I
think
part
of
it
is
also
just
I
can
you
know
I
actually
like
the.
I
always
wanted
a
command
line
tool
where
I
can
just
find
releases
and
jump
to
the
download.
D
A
To
get
us
get
a
sense
for
that,
but
I
think
by
and
large
the
biggest
problem
that
you
have
of
most
apis
is
just
get
the
concepts
right
right,
get
the
get
the
key
terminology
and
the
key
relationships
right
and
then
the
rest
is
just
more
or
less
the
long
tail,
but
I
think
we're
getting
close.
I
mean
the
api
is
not
super
large
either
right.
So
I
think.
B
B
So
latest
release
I'm
sorry,
it
gets
you
the
the
other
run
times
that
are
not
there
right.
So
it
might
tell
you
the
the
the
actual
version
of
the
latest
runtime,
but
what
the
release
will
get.
You
is
all
the
sdks,
because
the
release
can
potentially
have
multiple
sdks
and
the
release
will
give
you
back
the
specific
dot
net
core
aspirated
windows.
B
Yeah,
the
the
only
difference
there
is.
You
might
sometimes
be
interested
in
the
latest
release.
That
is
not
a
security
update
where
you
care
about
like-
and
this
again
is-
is
very
context,
specific
and
stuff
that
we've
encountered
with
writing
it
to
that
can
manage
the
installs
and
saying
my
centralized
department
has
a
policy
for
the
company
that
they're
trying
to
implement
and
that
they
need
to
meet,
and
I
might
care
about
the
latest
release
and
it
doesn't
necessarily
have
to
be
a
security
update.
A
So
but
like
let's
say
what
you're
saying
makes
sense
to
me,
but
then
the
question
is
given
the
object
model
right
now.
Presumably
latest
release
has
some
policy
to
fetch
the
latest
product
version
and
then,
when
I
call
get
really
get
latest
release
either
without
the
security
app
the
update.
You
have
also
some
policy
to
find
something.
So
if
I
now
say
get
latest
release
and
I
now
ask
for
the
product
version
of
that
release,
if
that's
different
from
what
latest
release
gives
me,
that
is
the
same
problem
more
or
less
right.
A
F
I
see
yes
yeah
I
mean
like
so
yeah.
I
think
the
the
position
is
take
all
the
things
all
the
properties
that
start
with
latest
delete
them
now.
There's
latest
release
and
get
latest
release
with
a
boolean
either
that
stays
as
a
method
or
that
becomes
latest
release
and
latest
security
release
and
yeah.
H
That
was
the
last
release.
I
don't
even
suggest
just
getting
rid
of
the
latest
release.
I
think
someone
could
easily
use
a
two-line
link
statement
over
that
releases,
collection.
A
I
mean
I
agree
with
that.
I
would
just
say
I
mean
I
think
these
methods
have
value
if
the,
if
the,
if
the
policy
is
super,
easy
to
understand
and
it's
the
most
common
policy
people
want
right,
I
mean
get
latest
release
seems
like
something
that
you
know.
Most
people
probably
want
right
like
it's,
the
whatever
is
the
latest
one
seems
like
a
very
reasonable
question
and
the
more
advanced
it
gets.
I
would
say,
yeah
at
that
point.
You
just
write
your
where
clause
right
because
well
you
you
ask
the
question
right.
A
B
B
F
F
A
B
Yeah
there's
been
like
and
related
to
that,
like
that's
one
of
the
reasons
why
I
brought
in
that
bull
property
called
is
out
of
support
because
there
is
often
a
lag
between
once
the
end
of
life
that
is
announced
and
a
channel
really
reaching
end
of
life
and
the
support
phase
changing
from
something
like
current
or
like
lts
to
end
of
life,
so
that
boolean
property
actually
looks
at
both
the
end
of
life
date
and
the
support
phase
to
make
that
decision,
because
there's
sometimes
a
lag
in
the
data.
A
Yeah
that
one
makes
sense
to
me
like
I
mean
I
would
just
say
that
things
like
you
have
a
nullable
date
where
you
effectively
have
a
logical
error
in
your
json
file.
I
think
that's
something
we
should
fix
at
the
json
file
like
or
I
don't
know
whether
you
can
compute
a
release
date
in
any
sensible
way,
but,
like
it
seems
a
bit
weird
to
like
just
forward
this
to
your
consumers
because
yeah,
I
don't
know
how
you
would
deal
with
that
right.
D
B
B
I
I
B
Yeah,
the
the
constructors
I
think,
needs
to
to
disappear
because
there's
other
than
I
think
for
for
lee.
There's
no
reason
for
people
to
ever
produce
these
files
by
themselves.
Right,
like
you,
would
always
consume,
everybody
would
consume
and
there's
literally
like
one
producer
in
the
world.
I
think
at
this
point.
D
A
A
Yeah,
if
you
really
wanted
that
file
to
be,
if
you
really
wanted
that
object
model
to
also
be
supportive
of
these
scenarios,
I
think
this
thing
would
need
a
major
overhaul
anyway,
and
that
will
probably
complicate
the
object
model
way
more
than
it
helps.
So
I
would
probably
just
scope
this
to
read.
Only.
F
Yeah,
I
would
put
on
release
channel
another
static
method
so
that
you
can
populate
just
one
release
channel
from
its
url,
because
right
now
you
have
to
have
built
the
bigger
thing
from
the
index
so
being
able
to
say,
like
whatever
we
end
up,
calling
release
channel
hey.
This
is
the
file
that
describes
you
go
load
yourself
and
return
the
populated
object.
I
would,
I
would
add
at
this
point
so
something
like.
Oh,
I
only
want
give
me
the.
F
I
mean
essentially
it
would
let
you
use
the
object
model
for
the
release,
builds
the
5.0
release
metadata
and
it
says,
like
great
now,
go
call
release
channel
dot
load
from
file
this
file.
If
we
can't
parse
it
fail.
The
build
like
something
went
wrong
where
do
not
move
this
forward
to
the
internet
and
there's
no
reason
for
it
to
go
load
the
big
index
file,
because
that
is
unrelated
to
the
process
of
producing
a
build
from
5-0
release
branch.
A
B
F
A
B
D
B
Want
to
download
a
full
release
when
I
can
there's
a
helper
called
files,
I
can
get
all
the
files
there
are
some
times
where
I
want
to
iterate
over
all
the
release,
and
I
don't
really
care
whether
I'm
dealing
with
with
an
sdk
or
runtime
specifically.
But
I
want
to
look
at
the
versions
and
stuff
like
that
that
are
common
to
whether
it's
a
asp.net
core
or
a
windows
desktop
release.
They
both
have
a
version.
I
care
about
that,
for
example.
Instead.
F
It's
a
little
weird
that
runtimes
is
the
I
release,
but
sdks
is
the
sdk
release
when
runtime
release
was
a
concrete
type,
yeah.
B
B
B
Core
runtime,
essentially,
as
I
don't
know,
clr
run
timer,
yeah,
ordinate
runtime,
or
something
like
that.
F
Off
the
json,
I
think
my
my
understanding
here
is
this:
release
is
the
verb
of
on
the
8th
of
september
2020.
We
released
3.1.8
and
then
that
has
oh
there's
the
asp.net
core
runtime
component
of
this,
which
lives
over
there.
A
Funny
you
have
the
external
that
I
just
came
up
with
as
well
like.
I
honestly
think
we
should
rename
I
release
to
released
component
and
then
you
would
have
sdk
component
and
windows
desktop
runtime
component,
and
then
you
have
a
clear
separation
between
the
release,
which
is
the
entire
thing,
and
then
the
individual
parts.
H
A
F
Yeah
and
then
so
I
release
yes
release
component
and
then
you
could
call
it
just
the
windows
desktop
component,
the
asp.net
core
component
and
then
for
lack
of
a
better
term
runtime
component,
and
then
it
would
be
release
dot
components
if
you
wanted.
B
E
B
A
Yep
and
then
it
means
we
need.
What
is
what
did
we
say?
We
said
so.
Sdk
release
would
become
release.
A
F
B
A
E
E
E
E
Yeah,
so
let
me
do
this
and
then
this
would
be.
F
Is
asp.net
core
dash
runtime?
I
just
think
that
it
didn't
need
the
word
runtime
there.
A
B
Does
that
mean
in
the
release?
There
are
some
releases
where
there's
single
sdk
and
that
is
under
the
sdk
entry,
but
there
is
also
an
array
of
sdks
where
we
ship
multiple
feature
bands
within
the
release,
so
say.
For
example,
in
t122
we
have
a
600
and
800
and
a
500
band,
so
the
sdk
would
always
point
to
the.
If
there's
multiple
sdks
the
sdk
entry-
and
we
can
correct
me-
always
points
to
the
highest
feature
band
within
the
release.
D
Because
in
the
json,
the
the
sdks
thing
was
added
when
we
reached
a
point
where
we
had
to
produce
these
multiple
feature
bands,
and
so
the
only
reason
it's
there
is,
you
know,
so
we
didn't
break
people
that
were
already
using
the
sdk,
so
hiding
that
particular
implementation
detail
makes
total
sense
to
me.
C
Ones
so
if
we
just
say
that
there's
always
multiple
ones,
I
think
that's
much
simpler,
so
that
yeah
I
like
that
and
then
people
can
just
look
for
the
highest
that
don't
want
to
understand,
which
feature
band
they're
interested
in
and
then
somewhere
I'll
check
with
with
lee
about
whether
we
trust
the
visual
studio
relationships
that
we
described
in
this
file.
I
don't
know
if
you've
captured
those
or
not.
B
F
B
So
there's
two
there's
the
visual
studio
version,
which
is
the
version
where
that
band
of
the
sdk
was
inserted
specifically
and
then
there's
also
the
visual
stereo
support,
which
means
that
if
you
have
that
version
of
visual
studio,
you
can
install
this
sdk
standalone
and
it
should
work
in
that
version.
But
the
visual
studio
version
is
this
is
the
version
of
visual
studio
where
this
sdk
actually
went
into
and
shipped
with
that
visual
studio.
F
Okay
and
somebody
somewhere
knows
how
to
get
the
string
visual
studio,
2019,
open
print,
v16.4,
close
paren
if
they
care
like,
if
you're
trying
to
find
which
one
can
I
install
on
this
computer,
that's
like
from
the
registry
or
something
that's
that
is
an
open-ended
question.
B
Okay,
yeah.
B
Yeah
I
mean
my
tool
today
can
like
query
some
of
the
stuff
in
visual
studio,
but
mapping
of
those
two
versions,
the
way
that
visual
studio
stores
it
and
the
way
that
we
present
it,
because
that
data
literally
gets
displayed
as
a
string
on
the
table
on
the
dot
net
website.
For
somebody
like
new
and
readable
text,.
D
Yeah,
that's
that
was
its
original
use
case
and
the
the
vs
and
vs
max
support
strings
are
structured
that
way,
because
when
I
typed
them,
I
thought
it
looked
nice.
F
Fair
enough,
I
guess
at
some
point
it
can
get
a
helper
utility
of
there,
like
helper
code
could
be
added.
That
does
like
a
registry
walk
on
windows,
and
it's
like.
I
think
this
is
the
sdk
you
want,
but
we
can
that's
a.
C
Pending
we
could
potentially
do
some
more
work
on
that
in
the
future,
but
but
right
now
I
I
don't
know
where
we're
gonna
people
will
use
that
other
than
it's
heavily
used
on
the
website
and
that's
why
the
pretty
display
is
important,
because
people
go
and
look
for
the
version.
They've
got
the
website's
extremely
confusing,
but
at
least
they
can
read
the
number
when
they
get
there,
and
so
that's
very
helpful.
F
Right,
well
I
mean
I
can
imagine
you
know
something
like
msit
running
a
thing.
It's
like.
Oh,
you
have
an
out
of
date
version
I'm
going
to
go
and
upgrade
your
sdk
for
you,
but
then
they
need
to
know
which
one
is
going
to
actually
work
based
on
the
vs
components
that
you
have
installed,
so
they
need
to
know
which
of
the
two
sdk
installs.
They
need
to
use
to
upgrade
you
and
you.
F
C
Yeah,
it's
actually
super
complicated
and
jack
has
just
spent
months
on
this
particular
problem.
I
think
that,
should
we
go
there,
it
would
be
an
additional
library
because
it
would
be,
it
would
be
way
more
complicated
than
people
think
it
will
be
and
very
limited
usage.
C
We
think,
and
it
would
be
very
window
specific,
so
I
would
like
to
keep
this
isolated
to
just
you
know
interacting
with
this
file,
which
does
include
a
visual
studio
number,
but
not
trying
to
go
any
deeper
into
that
visual
studio
number
and
then,
as
we
work
with
cseo
and
external
clients
on
the
tool
that
jack
that
drove
this
work,
then
we
may
find
that
there
are
people
that
want
to
write
their
own
tools
and
and
get
help
with
that.
C
So
we
may
split
that
off
into
an
additional
library,
but
I
think
it
would
be
more
like
more
like
partnering,
with
with
a
very
large
organization
that
wanted
help
to
do
something
like
what
we're
going
to
release
after
it's
checked
out
with
cseo.
A
B
So
runtimes,
the
idea
was
to
have
an
enumeration
of
all
the
things
that
are
considered
the
runtime
components
that
we're
calling
them
so
the
the
dotnet
runtime
the
windows
desktop
runtime
is
benedict
quarantine,
so
that
makes
up
all
there's
always
only
one
runtime
in
a
release.
I
don't
think
we've
ever
shifted.
A
C
And
I
think
if
we
have
that
listing
of
the
individual
components,
it
should
be
something
like
runtime
components
or
something
like
that.
While
there
is
a
level
at
which
the
runtime
asp.net
runtime
is
a
runtime
windows,
one
time
is
a
runtime.
I
don't
think
that's
the
way,
our
users.
Think
of
this.
I
think
they
think
of
the
runtime
as
5.0
big
blob,
and
so
we
I
might
get
tucked
out
of
that
position.
C
But
I
kind
of
think
I'd
have
some
since
sdks
is
a
set
of
versions
that
all
are
the
same
thing
and
the
runtime
concept
is
a
set
of
different
components.
We
should
probably
have
a
name
closer
to
runtime
components
if
we
want
to
to
share
that
which
we
might
because
there's
no
windows
runtime
prior
to
3.0
and
that.
C
B
C
C
That's
just
that
was
what
I
was
trying
to
break
with
that
comment
and
I'm
not
that
mad
components
may
not
be
the
best
way
to
break
it,
but
something
that
says
you
know
these
are
actually
the
different
subparts
that
make
what
you
think
of,
because
people
download
these
as
one
thing
they
download,
but
they
download
them
by
name
either
the
windows
runtime
or
the
whatever
we're
calling
the
asp.net
hosting
pack.
Now.
D
Is
is
calling
it
frameworks?
Does
that
break
the
concept
far
enough
away.
C
And
it
would
if
that
that
might
work.
The
only
concern
I
would
have
on
that
is
that
tfm
puts
us
with
framework
into
that
space,
and
I
don't
know
if
that
confused
people
I
just
want
to
you
know,
think
it
through.
I
think
all
of
this
just
deserves
a
little
attention.
I
also.
A
Think,
like
you,
you
want.
You
want
a
term
that
works
both
for
runtimes
as
well
as
frameworks,
because
the
thing
is
currently
we
have
this
eye
release
thing
which
basically
unifies
them.
So
if
you
use
the
term
framework
that
works
great
for
windows,
desktop
and
asp.net,
it
doesn't
work
for
the
runtime
itself,
and
so
but
then
runtime
is
a
term
that
only
really
works
for
the
runtimes.
I
think
I
don't
think
of
asp.net
core
runtime
and
windows
desktop
runtime.
I
think
that's,
that's
an
odd
way
to
put
it.
A
So
I
think
that's
why
I
actually
like
the
word
component,
because
it
is
a
thing
right
and
there
might
be
some
way
to
acquire
them,
but,
like
most
people,
don't
think
of
this
as
acquisition
right,
they
install
the
whole
thing
and
then
they
run
restore
and
things
are
happening
right.
They
don't
really.
F
Yeah
I
mean
to
make
it
simple
and
so
that
you
know
people
can
or
we
can
understand
it,
much
less
other
people.
I
would
do
it
as
components
which
contains
the
three
different
runtime
components
and
all
the
sdk
components,
and
if
someone
wants
the
non-sdk
components,
they
can
add
the
exclusion
filter
themselves
when
they're
enumerating
it.
I
F
But
really
they're,
probably
just
going
to
grab
the
property
of
the
kind
they
care
about,
and
given
that
the
the
run
times
property
here
isn't
actually
mirroring
a
single
concept
from
the
release
it.
I
also
sort
of
slightly
question
if
we
want
it,
but
if
we
do
want
it
just
add
everything:
don't
differentiate,
sdks
from
runnable
components,
because
the
world
will
get
hard.
C
F
C
Would
be,
you
would
be
if
you
were
looking
at
for
out
of
date,
components
or
you
were
looking
at
doing
acquisition,
updating
on
a
machine.
You
would
be
in
those
cases,
so
there
are
some
cases
where
you
would
be
looking
at
all
of
those
I
expect
we
would
be
as
part
of
the
acquisition
when
we
ask
that
when
we
have
a
gesture
that
says,
show
me
everything
out
of
date
on
this
machine.
We
would
that's
what
we
would
be
checking
for.
D
A
D
A
A
To
say
yep,
you
only
want
to
upgrade
a
runtime,
but
you
don't
want
to
upgrade
the
sdk
or
something.
But
I
feel
like
the
problem
with
trying
to
like
do
these
splits
by
by
job
is
a
bit
hard
to
understand
what
the
jobs
are
like.
I,
I
feel
a
bit
more
comfortable,
just
saying:
let's
model
the
data
that
we
have
and
then
expose
it
in
a
terminology
that
is
understandable
and
then,
if
there's
more
specialized
functions
we
need
to
add.
You
probably
want
some
methods
or
something
like
this-
that
that
applies
some
reasonable
policy.
C
C
A
C
I'm
gonna
have
to
run
to
another
meeting,
I'm
afraid
so
I'm
gonna
say
goodbye
and
I
look
forward
to
following
up
with
with
jack
and
whoever
else
afterwards.
But
I'm
gonna
have
to
say
goodbye.
A
That
works,
so
I
just
pasted
in
the
notes
that
I
took,
and
I
would
say,
let's
meet,
maybe
two
weeks
from
now.
I
don't
know
how
much
time
john
needs
to
actually
take
a
pass
on
it,
but
I
also
would
like
to
use
next
me
next
view
to
next
meeting
sorry
next
week's
meeting
to
actually
review
the
other
things
we
now
have
on
our
backlog.
So
would
two
weeks
work
from
now
or
do
you
need
something
in
the
middle
of
jack.
B
A
Perfect
then
this
is
it
thanks?
Everybody
cool.