►
Description
Community links for this week: https://www.one-tab.com/page/2yXwvHB1RhGyODL1FedlLg
B
A
A
B
A
B
A
B
A
A
B
A
A
B
A
B
A
B
A
A
B
A
Alright
well
I
will
say
this
headset
mic
well,
as
bright
points
out
is
quite
tinny.
It
still
sounds
more
crisp
like
it's
a
higher
frequency
like
a
higher
sampling
rate,
whereas
when
you
had
the
other
mic
plugged
in
it
just
sounded
flat,
it
literally
sounded
like
you
want
elephant
I
sound
like
I,
was
recording
a
bad
Skype
call
that.
B
Could
be
that
I
had
like
a
wrong
setting
on
it
like
I
bet,
there's
something
where
I
could
go
in
condensed.
Ur
mics
are
funky
like
because
they
they
can
pick
up
from
an
entire
room,
they're
kind
of
more
broad.
Then
you
have
to
like.
Then
they
do
stuff
to
prevent.
Echoing
and
all
that,
so
you
have
to.
A
A
A
B
A
B
A
B
Know
talks
about
some
of
the
first
of
all
why
you
need
HTTPS.
He
talks
about.
You
know
new
features
with
dev
certs
into
one
which
I
love
showing
that
off
I
have
one
minor
minor
quibble
in
here.
Is
it
says,
SSL
I
know
it's
it's
way
too
anti
pal
there
yeah
yeah,
it's
it's
spent
TLS
for
a
while
right,
SSL
is
and
yeah.
A
A
A
Yes,
yes,
OHP
Nicolle
to
just
to
refresh
people's
memories.
Hb2
is
supported
by
Kestrel
in
a
spirit
core
22.2.
Sorry,
it
is
not.
It
will
not
be
on
by
default.
You
will
have
to
enable
it
and
the
reason
for
that
is,
we
haven't
finished
it
yet.
So
it
is
functional
and
it
works
quite
well,
but
it
hasn't
gone
through
the
same
levels
of
rigor
and
testing
that
we
have
been
able
to
put
the
HTTP
1.1
through.
A
B
Right
so
here's
one
from
Andrew
lock
and,
as
always,
a
pretty
meaty
post
from
him.
So
this
is
talking
about
I,
mean
configure
options
and
configure
all
so
talking
about
now
this
this
is,
you
know
a
lot
of
times.
A
lazy
way
of
doing
options
is
just
reading
them
in
the
here
he's
talking
about
strong.
You
know,
like
named
instance,
named
options.
B
A
I
think
what
happened
is
again.
This
is
something
that
has
evolved
since
the
beginning
of
a
spinet
call.
We
didn't
have
named
options
in
the
first
couple
of
versions,
and
then
it
was
required
for
scenarios
where
you
want
to
use
a
single
subsystem
like
identity
or
the
authentication
handlers
and
then
do
some
type
of
multi-tenancy,
where
you
have
different
instances
of
open
or
for
exam
that
you
want
to
configure
separately
based
on
different
paths
or
me,
or
something
else
like
that.
A
That
means
you
have
to
have
different
instances
of
the
options,
types
that
configure
those
subsystems
that
you
have
to
separate
them,
because
it's
all
di
you
have
to
have
a
way
of
saying
well,
I
want
the
open,
API
or
open
or
options
for
this
instance
of
my
subsystem
versus
that
instance,
and
it
can't
be
type
base,
because
the
DI
resolution
system
is
already
done
based
on
type.
So,
if
you
say
give
me
the
open
or
options,
you
know
the
T,
you
won't
know
we're
trying
to
give
you
so
named.
A
Options
is
the
ability
to
say
well,
yeah
I
have
an
options.
You
know
instance
called
foo
and
one
called
bar
one
called
bars
now
that
method
I'm
assuming
configures
all
of
them,
so
doesn't
matter
what
the
name
is
you
just
get
all
of
them.
The
reality
is.
The
optional
system
under
the
covers
is
always
named
options.
If
you
configure
one
without
passing
your
name,
it
gets
like
a
default
name,
and
that
is
the
default
instance.
It's
just
a
fixed
name.
It's
like
it's
an
empty
string
or
something
like
that.
A
So
yeah,
not
a
lot
of
folks
have
to
use
named
options
most
of
these
sort
of
run
in
the
mill
scenaries.
You
don't
need
it.
It's
only
when
you
start
doing
things
a
little
more
advanced
where
you
need
to
have
like
I,
said
more
than
one
sort
of
carved
out
space
for
a
given
set
of
things
like.
Maybe
you
want
to
run
MVC
twice
in
the
system.
I,
don't
know
why,
but
often
it's
when
people
are
trying
to
do
things
like
multi-tenancy
cool
all.
B
Right,
cool
here's,
a
health
check
I've
been
enjoying
looking
at
health
checks,
so
this
is
a
register
distributed
cash
health
check,
so
I
I,
just
I,
don't
know,
I've
done
some
demos
on
showing
health
checks
and,
and
lately
and
I,
really
like
kind
of
the
idea.
There's
there's
some
in
the
repo,
the
health
checks,
repo
there's
some
samples
but
I
also
like
seeing
other
people
in
the
real
world
ready
or
you
know,
outside
of
Microsoft
right
in
them
as
well.
So
here's
who's
going
through
and
implementing
this
Redis
distributed
health
check
so
yeah
all
right.
B
A
Good
information
to
know
about
we
people
have
asked
us
for
strong
recommendations
in
the
past
about
what
they
should
do.
Regarding
some
of
the
guidance
that
may
or
may
not
have
been
debated
in
the
past
publicly,
you
know
strong,
naming
or
whether
to
use
keys
or
how
you
do
TFM
multi,
targeting
which
TFM
should
you
target?
A
Then
you
really
need
to
think
about
you
know
what
does
standard?
Do
you
have
to
up
target
to
a
specific
TFM
to
get
certain
features?
Sometimes,
how
does
that
affect
your
packages?
Should
I
strong
name,
etc,
etc,
etc.
So
this
is
a
good
set
of
initial
guidance.
I
think
that
will
hopefully
put
some
of
those
questions.
B
B
So
he
first
shows
you
know
just
blowing
out
the
old
client,
app
folder
and
doing
ng
new,
but
then
later
on
and
talks
about
some
of
the
features,
support
for
there's
material
update,
there's
drag-and-drop,
there's
virtual
scrolling,
which
is
cool,
and
then
he
also
shows
down
at
the
end
here
about
you
know
upgrading
as
well.
So
if
you
have
an
existing
app
there's,
this
ng
update.
So
it's
nice
to
see
the
you
know
that
kind
of
payoff
of
working
with
the
angular
CLI
in
the
spa
template
science
yep.
B
Alright,
here
is
an
interesting
one.
This
is
a
an
e-book
from
Vincent,
so
this
is
a
64
page
e-book,
and
this
is
on
docker
izing
asp,
net
core
and
blazer
apps
on
a
Mac,
so
I've
seen
you
know
we
there's
some
ebooks
out
there
and
things
on
asp
net
core.
This
one's
interesting
to
also
look
at
blazer
as
well
so
64
pages
in
here,
there's
quite
a
bit
info,
so
you're
way
down
towards
the
end.
He's
got
some
information
on
on
here.
You
know
it
goes
through
and
builds
out.
B
This
one
is
command
and
mediator
pattern,
so
this
is
I,
don't
want
to
say
your
name,
wrong,
I
think
it's
Koran,
so
talking
about
the
command
pattern,
why
you
would
use
it
and
using
mediator
to
implement
it.
So
it
goes
into
two
examples,
and
this
is
working
with
user
registration,
so
the
scenario
of
a
user
registers,
and
then
we
do
several
things
we
send
out.
You
know
we
stored
the
person,
but
we
also
send
out
maybe
an
email
message.
Sms
we
log
things.
B
So
so,
there's
you
know
a
simple
or
it
shows
you
know
getting
it
set
up,
and
you
show
us
a
simple
pattern
of
just
registering
the
person
and
then
the
second
example
kind
of
pulls
all
this
stuff
in
together,
all
at
once
so
showing
register
a
user
and
then
do
all
the
things
so
and
I
interesting
there.
This
one
is
from
Dave
click,
so
Dave
is
digging
into
the.
B
This
is
a
long
post
where
he
shows
all
these
internals
and
then
at
the
end
a
spoiler
alert
at
the
Andy
says:
hey,
there's
libraries
that
will
do
this
for
you,
but
it's
still
very
interesting
to
see
exactly.
What's
going
on
here
so
he's
talking
about
actually,
like
you
know,
rendering
razor
on
your
own,
so
in
your
application
generating
code
using
using
razor
so.
A
B
So
so
all
this
stuff,
as
far
as
hosting
compiling
loading,
the
assembly
cetera.
So
this
this
is
pretty
cool.
If
you
want
to
use
razor
on
your
own
outside
of
asp,
net
core
and
then
where's
snow
stay
away
from
the
silly
ads,
so
he
does
down
at
the
very
end
talk
about
Gaza,
Raider
and
razor
light.
So
those
are.
Those
are
two
kind
of
libraries.
If
you
want
to
do
this
on
your
own
cool,
all
right
all
right.
If
you
want
to
do
this
without
writing
all
the
code
here,
we've
got.
B
This
is
just
a
neat
one
here.
This
is
from
chart
a
and
he's
he
went
in.
He
had
to
support
an
existing
API,
that's
written
with
PHP
and
so
he's
just
showing
that
you
know
by
using
attributes
routing
on
a
controller,
very
easy
to
maintain
those
existing
routes.
So
just
thought
that
was
that
was
cool
chain
said:
I
have
this
some
this
extension
that
puts
my
tabs
to
sleep
if
I,
if
they're,
if
they're
idle
for
too
long.
So
that's.
B
So
Shane
went
through
and
so
and
Shane
by
the
way
on
the
on
the
chat
which
was
cool
to
see
so
here
he's
okay,
cosmos
DB
has
support
for
to
be
as
well
like
the
the
same
protocol
or
whatever
same
syntax,
and
so
here
he's
showing
using
MongoDB
locally
and
cosmos
to
be
in
production,
and
so
he
shows
how
to
set
that
up
using
docker.
So
so
this
is
a
race
tracking,
app
I
love
the
names
of
his
races.
B
By
the
way
things
like
team
oriented,
high-level
access
race
sounds
like
one
to
get
into
so
then
he
goes
through
and
shows
us.
You
know
the
different
docker
files
pointing
at
setting
it
up
for
running
locally,
and
you
know
I
just
I,
just
like
seeing
some
interesting
things
in
here
like,
for
instance,
your
user
secrets,
are
you
know
off
in
your
route,
Microsoft
user
secrets,
etc.
So,
one
of
those
in
so
anyhow
going
through
and
and
showing
that
so
this
is
set
up
to
run
MongoDB
locally
in
cosmos
in
production.
Okay,
another
razor
run
here.
B
B
A
Getting
them
into
the
library
is
one
step
having
them,
then
be
served
as
part
of
referencing
that
library
and
playing
well
with
the
existing
static
file
middleware
or
you
know,
whatever
you
already
have
configured
in
your
application-
is
the
other
part
of
that.
Now
we
did
this
for
the
default
identity,
UI
that
we
added
right.
B
A
But
we
didn't
first
class
it
to
the
point
that
we
kind
of
built
an
end-to-end
for
anyone
trying
to
do
that.
Very
simply,
it
is
something
that's
on
our
plans
as
part
of
Razer
components
and
three,
oh,
and
there
is
something
already
in
the
blaze
of
stuff
today.
That
does
something
it's
a
little
hacky.
Well,
we
need
to
come
up
with
a
better
way
of
making
it
smoother,
but
it's
not
straightforward.
You
know
you
very
quickly
if
you
think
of
how
web
forms
did
this
in
system
web.
A
Just
works
and
I
have
my
I.
Have
a
component
I
want
to
look
good,
but
I
also
want
the
ability
to
like
take
its
assets
and
optimize
them
or
replace
some
of
its
assets
or
have
some
control
over
where
the
assets
get
placed
in
my
project
or
how
they're
served
from
my
application,
like
those
two
things
are
pretty
much
completely
at
odds
and
so
we're
trying
to
find
that
right.
Balance
between
you
drop
a
component
in
and
it
just
works
and
I
can
guess.
The
consumer
of
a
component.
B
B
Played
quite
a
lot
of
that
yep,
so
you
can
watch
me
I'm
gonna
play
it
live.
So
this
is
neat-
and
here
you
know
the
source
code
out
here
as
well,
along
with
a
lot
of
others
here,
he's
got
he's
got
several
listed,
so
need
to
see.
If
you
want
to
dig
in
this,
this
is
funny.
You
know,
obviously
something
like
writing
a
game
as
a
thing
we're
having
the
kind
of
client-side,
UI
and
state
and
all
is,
is
something
that
we
harder
to
do
right.
B
Otherwise,
all
right,
Damian
Bowden,
so
here
this
is
implemented,
he's
been
doing
some
things
on
identity
recently
and
integrating
with
identity
server
on
the
backend
and
stuff.
So
here
he's
looking
at
client
custom
claims,
so
it
claims.
Of
course
you
know
much
more.
This
is
the
kind
of
advanced
next
step
beyond
like
just
users,
logging
in
and
simple
roles
and
stuff.
This
is
being
able
to
have
multiple
claims
associated
with
the
user.
B
So
here
here
he's
got
that
policy
for
an
admin
setting
that
up
and
associating
it,
and
then
you
know
the
the
end
result
here
is
being
able
to
login
and
being
able
to
associate
people
with
an
administrator,
so
anyways
neat
stuff
there,
okay
Hashem!
So
when
I
read
this
I
started
thinking
where
have
I
seen
more
SJS
before
with
an
asp
net,
and
it
was
actually
him
so
hashem
first
had
done
a
chart
control
with
a
tag
helper
and
morris
jeaious,
and
so
then
he's
taken
this
now
and
extended
this
to
working
with
blazer.
B
So
this
is
a
blazer
component
with
morris
j
s,
which
is
a
charting
library
and
he's
talking
about
how
he's
really
happy
to
work
with
a
component
model
and
how
that's
that
is,
you
know
a
lot
simpler
to
implement.
So
so
here's
got
a
blazer
chart
component
and
he's
using
you
know,
j
s
interrupt
to
call
into
the
the
javascript
library
calls
and
then
the
end
result.
You
know
a
beautiful
beautiful
chart
here
and
as
well
as
you
know,
this
markup
is,
is
pretty
lightweight,
so
all
right
cool
that
is
very
cool,
yeah
I'm.
B
Looking
forward
to
seeing
the
components
people
build
out
for
these
all
right,
almost
done
here,
I've
got
two
things
that
I
saw
a
David
Fowler
tweet
recently.
So
one
is
is
interesting.
This
is
guidance
on
writing
scalable
services
in
asp
net
core
yep
yeah.
So
the
first
page,
you
know
it
looks
like
a
very
short
and
then
you
dig
in-
and
there
is
a
ton
of
information
in
here.
So
you
know,
fund
reading,
explaining
and-
and
this
is
work
in
progress,
Serbia.
A
A
The
intent
here
is
that
this
will
end
up
being
a
dog,
and
this
is
good
of
him
if
I,
just
sort
of
brain
dump
a
whole
bunch
of
things
that
we've
seen
this
isn't
just
based
on
opinion.
This
is
stuff
that
we've
literally
seen
in
customers
apps
that
cause
issues
it's
some
of
this
is
related
to
the
talking
and
I
gave
at
industry
London
last
year
about
diagnose
ability
and
AIDS.
A
We
don't
net
core
applications
and
so
yeah
this
and
the
other
other
goal
here
is
that
every
one
of
these
code
samples
we
want
to
have
an
actual
functional
sample
that
you
can
run
and
see
this
problem,
reproduce
when
under
the
right
conditions,
and
so
alright,
and
so
a
lot
of
these
times.
This
just
looks
like
oh
yeah.
Don't
do
this
thing
do
this
thing,
but
it
can
be
kind
of
difficult
to
understand
why
so
I
think
the
first
part
of
this
document
is
very
much
just.
Let
don't
do
this
pattern.
A
Do
this
and
here's
why
and
then.
The
second
part
is
a
lot
of
well.
You
know
help
me
understand
why
this
is
bad.
Let's
do
something
more
real
real
world,
and
then
they
try
and
show
some
more
examples
to
say
in
the
controller,
doing
calling
a
library
that
you
perhaps
don't
own
and
then
inside
that
library
they
might
be
doing
one
of
these
things
and
then
how
does
that
affect
your
application?
Well,
a
lot
of
folks
have
like
well
I.
A
Do
some
of
these
things
and
it's
fine
and
the
reality
is
that
yeah,
it
might
be
fine.
These
are
things
that
can
lead
to
problems
in
your
application
if
they
don't,
if
they,
if
they
exist
in
your
app.
You
of
course,
might
be
fine
until
a
certain
point
of
leave
generally,
and
it's
all
to
do
with
how
your
application
can
deal
with
bursts
of
load
or
even
sustained
load
that
gets
to
once
it
gets
to
a
certain
thrush.
A
In
some
cases,
if
you
have
some
of
these
patterns
in
your
application,
you'll
be
able
to
a
handle
a
burst
because
the
burst
goes
away
and
then
the
runtime
and
the
thread
pool
is
able
to
recover
because
near
the
load
disappears
and
the
backlog
of
work
that
is,
that
is
often
built
up,
allows
can
now
be
can
be
cleared
out.
If
that
load
gets
over
a
certain
threshold,
though,
and
then
maintains
that
level
the
app
will
never
recover.
It
becomes
a
degenerative
scenario.
A
A
You
could
happy
perfectly
fine
at
eight
requests
per
second
and
then,
when
you
get
to
nine,
if
it
stays
at
nine,
the
app
will
never
recover,
and
so
we
have
demos
that
showed
this
on
stage
at
in
DC
London
and
one
of
the
goals
of
this
is
to
have
apps.
You
can
run
with
a
time
inside
a
harness
or
wither
with
a
sidecar
tool
that
you
can
like
adjust
the
load,
and
you
can
see
it
fail.
A
So
you
can
say:
oh
it
looks
to
be
running
fine
it
when
I
give
it
20
requests
per
second,
but
as
soon
as
I
try
and
make
it
go
up
to
25,
it
doesn't
ever
recover,
even
if
I
pull
it
back
from
25
30
seconds
later.
The
app
just
cannot
recover
because
there's
too
much
work
backed
up
and
so
I
think
having
these
type
of
examples
will
help
people
understand
why
these
issues
can
come
around
and
what
they're
so
important
to
try
and
avoid
them.
Obviously,
a
doc
is
a
great
first
step.
A
We'd
love
to
get
to
the
point
and,
as
part
of
our
plans
for
300,
is
to
try
and
make
it.
So
it's
very
difficult
to
get
into
the
situation
in
the
first
place,
because
you
know
the
tools
and
the
the
language
and
just
the
runtime
warned
you
against
these
things
and
make
it
be
very
hard
for
you
to
actually
put
these
things
in
your
app
in
the
first
place.
But
first
step
is
good.
Doc's
cool.
B
A
Blog
post,
so
there's
no
stuff,
that's
good,
yeah!
No,
so
that
the
first
one
there
David's
post
is
about.
So
we
have.
The
web
host
type
today
was
in
every
eight
minute,
core
application,
there's
a
program
main
in
which
there's
a
couple
lines
of
code
that
you
know
boot
the
Asiata
neck
or
host
offer
type
called
web
host,
and
that
returns
an
eye
web
host
builder
that
you
then
call
build
on,
and
that
gives
you
an
instance
of
a
web
host
that
you
call
start
or
run
on
you
know.
A
Asp.Net
is
one
of
the
things
about.
It's
been
a
core,
that's
very
different.
Different
from
the
past
he's
been
on.
There
is
that
it
is
a
it's
a
sort
of
a
managed
hosting
model,
it's
in-app
hosting,
so
your
application
is
a
console
app.
It
is
like
you
run
at
the
command
line
and
it
starts
up
like
any
other
console
application.
It's
not
a
special
host
booting.
The
CLR
like
we
had
in
is
that
you
need
a
different
server
or
a
different
thing
to
actually
host
your
application.
A
Like
is
it's
a
console
app
the
web
host
is
the
thing
that
lets.
You
start
that
host
up
and
you
can
have
more
than
one
in
your
application.
If
you
like
the
problem
with
web
host,
is
that
it's
tied
to
web
applications
and
by
web
I
mean
ones
that
serve
HTTP,
but
we,
as
we
know
in
the
world
of
server
programming,
there
are
lots
of
other
protocols.
There
are
lots
of
other
things
that
you
might
want
to
run
on
it
on
a
quote-unquote
server.
They
may
not
even
accept
requests.
A
There
might
be
things
that
DQ
jobs
from
a
background
service
or
from
the
message.
Bus
or
you
know,
just
do
batch,
we
wake
up
every
you
know
five
minutes
and
do
a
batch
processing
and
those
are
still
server
applications
in
the
sense
that
they're
not
running
on
your
desktop
or
somewhere.
They
run
as
part
of
your.
You
know,
larger
server
infrastructure
and
all
the
things
that
we
built
phrase
Pinet
call
you
know,
dependency,
injection
and
logging
and
configuration,
and
this
hosting
model
the
composition
of
middleware.
A
You
know
modular
whatever
your
pipeline
is,
you
may
not
have
an
HTTP
pipeline.
You
might
have
a
queue
processing
pipeline
or
a
TCP
pipeline,
but
you
have
the
concept
of
code
that
runs
on
events
that
happen
over
the
lifetime.
Those
concepts
are
applicable
to
all
those
application
model
types,
and
so
the
concept
of
a
generic
host,
as
opposed
to
a
web
specific
host,
took
hold
around
the
terreiro
timeframe.
I
think
we
actually
shipped
the
type
in
2.1,
but
the
problem
with
that
and
it
lets
you
you
know,
do
all
the
thing
I
talked
about.
A
You
can
use
all
those
Microsoft
that
extensions
dot,
X
and
subsystems
and
get
the
same
benefits.
You
can
use
the
same
logging,
the
same
configuration,
etc,
etc.
But
you
can't
put
a
server
in
a
generic
host
easily
because,
for
example,
all
the
extension
methods
and
types
that
we
built
to,
let
you
boot
those
up
rely
on
the
web
host
type
I
web
host,
not
the
new
I
hosted
type,
and
so
we
need
to
rationalize
that
as
part
of
three
oh
and
the
plan
is
to
effectively
deprecated
the
web
host
boot
up.
A
The
current
plan
is
that
it
would
still
be
in
three.
Oh
there's
no
point
removing
it
like
you
were
just
it's
just
another
hurdle
for
people
moving
their
applications
to
three,
oh,
but
the
new
applications
would
all
be
booted
up
whether
they're
web
applications-
or
you
know,
different
server
applications
would
all
be
booted
up
through
this
generic
host
and
so
there's
a
fair
bit
of
work
involved.
Obviously
duplicate
all
the
extension
points
that
we
have
on
web
host
and
the
things
that
hook.
Those
extension
points
on
two
generic
hosts,
there's
also
all
the
startup
patterns.
A
A
And
yes,
we
may
end
up
removing
some
patterns.
Someone
commented
yesterday.
There
are
some
fairly
lesser-used
patterns
that
we
did
add
to
the
web
host
that
are
particularly
well
documented
and
not
used
like
you
can
have
the
configure
services
method
and
the
configure
method
on
your
startup
class.
They're
not
typed,
like
you,
don't
implement
interface
to
get
those
they're
all
pattern
matching
based
and
you
can
have
configure
environment
name
services
and
we'll
find
that
and
call
that
if
the
current
environment
name
matches
that
one.
A
But
we
don't
see
that
user
like
it's,
not
in
the
templates,
we've
never
shown
it
in
a
demo.
I,
don't
think
anyone's
ever
shown
it
in
a
day
from
the
team,
but
it
was
there
because
we
thought
during
beta
four
or
something
in
the
original
release.
We
thought
that
might
be
an
interesting
pattern,
so
some
of
those
things
that
we've
not
you
know
that
are
particularly
used
and
may
not
carry
over
into
the
new
thing
that
you
might
see
those
fall
away
in
the
new
generic
ho
stuff.
A
B
A
The
sort
of
the
first
announcements
around
a
screen
it
core
3
and
some
of
the
changes
that
will
happen.
These
are
sort
of
foundational.
It's
not
a
feature
post,
I'm
gonna
do
a
feature
post
later,
probably
next
week
or
so,
and
I
can
talk
about
feature
plans
today,
it's
kind
of
what
I
hope
to
do
as
a
precursor
to
the
next
post.
This
post
was
about
heads
up
for
some
sort
of
major
platform
level
changes.
A
You
know,
then
some
of
these
are
breaking
changes,
and
so
we
wanted
to
give
folks
a
very
early
look
at
some
of
these
changes
before
we've
even
finished
to
point
to
like
2.2,
we'll
ship
later
on
in
the
year,
we've
done
the
final
preview
that
was
preview.
We
haven't
shipped
the
first
preview
of
300
yet
so
now
is
a
good
time
to
make
some
of
these
announcements.
A
So
the
first
one
was
around
packages
versus
frameworks
and
there's
a
bit
of
history
there
about
how
a
spinette
core
was
originally
conceived
five
years
ago
or
more
as
a
bunch
of
packages
and
NuGet
would
be
the
center
of
the
world
etc,
etc.
We
ran
into
a
whole
bunch
of
problems
or
issues
with
that
and
trade-offs
that
we're
very
difficult
to
make,
and
so
in
a
spoon,
eight
core,
three
we're
landing
in
a
place
where
a
lot
of
stuff
will
still
say
as
packages,
especially
things
that
sort
of
more
BCL
II.
A
So
everything
in
Microsoft
that
extensions
dot
star,
which
is
that
weirdly
named
set
of
packages
that
we
created
to
create
sort
of
more
modern
application,
focused
ap,
is
for
logging
in
config,
and
those
type
of
things
rather
than
the
more
static
type
of
AP,
is
that
we
hadn't
done
their
framework
before
they
will
remain
as
packages,
and
you
can
use
those
you
know.
Interview
framework
will
continue
to
use
those
in
a
different
record
shape.
I
should
say
the
signal
a
client
uses
those.
A
A
It's
always
been
available
packages,
but
it
was
also
included
in
the
asp.net
call
and
a
spinet
called
app
shared
frameworks
that
we'll
won't
continue
and
you'll
just
need
to
add
the
package
referee
and
D
framework,
or
it
just
means
it's
like
every
other
data
access,
library,
okay
and
a
simpler
in
the
sense.
The
energy
framework
or
one
of
its
key
benefits,
is
that
it
runs
kind
of
everywhere
runs
on
every
net
which
the
previous
entity
framework
didn't,
and
so,
in
order
to
facilitate
that
it
has
to
run
his
packages.
A
There's
kind
of
the
only
way
to
do
that
and
then.
Lastly,
the
big
part
of
this,
obviously,
is
that
a
spinet
core
3
will
effectively
just
be
part
of
dot
nickel
3.
So
it
is,
we
shipped
it
as
a
shared
framework
in
2.1,
which
was
the
default
experience,
but
we
also
had
packages
that
were
dotnet
standard
base,
which
means
that
you
could
run
them
and
dotnet
framework,
because
a
spinet
core
one
and
to
support
running
on
dotnet
framework
that
causes
little
confusion.
A
Now
it
looks
like
a
good
time
for
us
to
to
make
that
to
make
that
jump
to
basement
at
core
3
being
exclusively
a
dotnet
core
3
and
above
thing
it
also
means
that
a
spirit
core
can
much
better
start
utilizing
all
of
the
features
that
are
only
going
into
dotnet
core.
Now
we
started
this
again
in
2.1
with
it
with
span,
and
frankly,
it
was
a
little
work.
It's
actually
quite
a
lot
of
work
to
support
the
a
spirit
core
running
on
new
api.
A
Is
that
a
dotnet
core
specific,
while
also
sort
of
maintaining
them
back
with
compatibility
to.net
that
won't
support
those
api's
or
can't
for
whatever
reason?
And
so,
as
I
said
this,
this,
this
transition
allows
a
spinet
call
three
to
really
fully
leverage
and
utilize
all
these
great
enhancements
that
are
coming
to
dotnet
core
and
in
a
lot
of
cases,
a
spinet
cause,
workloads
and
features
are
driving
the
addition
of
those
api's.
A
Is
it
just
allows
us
to
move
that
much
quicker
and
sort
of
innovate
at
a
in
a
better
way?
So
that's
the
first
part
of
that
announcement.
I
think
all
their
first
and
second
parts
I
may
have
put
two
together.
The
third
part
was
about
you
know
what
we're
also
the
L
part
was
that
the
the
Shedd
frameworks,
as
they
are
those
core
platform
pieces.
Those
are
things
you
have
to
install
on
a
machine
like
a
runtime
before
you
can
run
the
application
to
date.
A
We
had
included
some
third-party
components
in
there
like
things
that
we
don't
compile
things
that
we
don't
have
the
capability
of
servicing,
because
we
don't
own
the
new
get
packages
and
that
does
cause
some
issues.
There's
a
couple
of
issues
that
cause
this
one
is
well,
we
can't
service
them,
and
so,
if
something
goes
critically
wrong,
we
have
to
work.
You
know
basically
go
ahead
and
hand
to
some
other
party
and
say:
can
you
really
really?
A
Please
fix
this
issue
because
we
physically
are
incapable
of
fixing
it
like
because
of
the
way
dotnet
identity
works
and
the
way
new
get
identity
works?
We
don't
even
have
a
technical
mechanism
for
shipping
changes
to
those
without
breaking
anyone.
Everyone
else's
code,
unless
the
original
component-
or
that
does
it,
and
so
we're
removing
that
problem
and
saying
no,
this
very
core
part
of
the
platform,
this
shared
framework
part,
is
always
guaranteed
to
be
something
that
we
can
service.
The
the
second
part
is
around
well,
obviously,
you
know
doing
that.
A
It
doesn't
mean
that
we
don't
love
open
source
and
we
don't
want
integrate
with
open
source.
Of
course
we
do
and
so
that
the
third
announcement
there
is
that
for
some
of
the
more
modern
workloads
we
have
to
it's
a
more
of
an
open
recognition
and
embracing
of
the
fact
that
we
have
to
really
use
third-party
components,
or
it's
certainly
a
good
approach
to
use
and
better
integrate
with
some
of
these
third-party
open-source
components
to
deliver
a
great
end
to
end
out-of-the-box.
A
A
You
need
to
do
standards-based
api
authorization
and
why
you
should
we
go
and
build
those
again
when
there's
already
perfectly
reasonable
solutions
and
popular
not
just
reasonable
but
popular
and
very
well
supported
solutions
in
the
community,
and
so
that's
one
of
the
things
they
are
point
out
there
things
like
add
empty
server
that
we've
done
some
work
to
better
integrate
with
as
part
of
the
wave.
We
saw
things
like
the
pali
support
that
we
added
into
one,
and
so
we
added
a
should
be
client
factory.
A
We
didn't
add
all
the
retry
policies
and
things
that
their
client
factory
was
designed
to
sort
of
allow
you
to
do.
We
simply
said
use
poly,
and
we
worked
with
the
poly
authors
to
make
sure
that
it
worked
well
with
the
client
factory
and
we
have
Doc's
that
talked
about
how
to
do
that
and
as
the
post
talks
about
you
know,
that's
that
that
type
of
support
or
integration
will
take
different
forms.
A
A
Yeah,
it
said
these
are
you
know
and
that
that
does
present
some
problems.
You
know
some
issues.
I
should
say
that
we
have
to
work
through
because
once
they're
in
the
default
experiences,
there's
expectations
around
from
our
customers
as
to
support
and
longevity
and
all
those
types
of
things
yeah
the.net
foundation
can
help
for
a
lot
of
those
things,
because
certain
err
foundation
includes
policies
for.
A
You
so
very
phallic
and
source
library
owner
decides
they
don't
want
to
own
the
library
anymore,
or
you
know,
God
forbid
something
terrible
happens
to
them.
Then
there
needs
to
be
a
continuity
plan
in
place
that
can
transition
the
ownership
to
someone
else.
You
know
sort
of
under
the
under
your
consistent
guidance
and
policies
and
all
the
rest
of
it
then
also
things
like
secured
updates.
A
We
open
sourced
our
own
frameworks.
We
we
take
PRS
from
the
community.
You
know
we
have
open
issues
that
people
can
comment
on,
etc,
etc.
But
for
me
the
next
phase
is
that
great?
How
do
we
use
that
phase
to
then
set
up
the
next
phase,
which
is
well?
How
do
we
make
it
so
that
it's
more
common
for
our
customers
to
not
question
the
use
of
open-source,
even
if
it
doesn't
come
from
Microsoft,
which
we
have
seen
in
other
communities,
whether
it's
the
Java
community
or
the
node
community,
for
example?
A
And
it
doesn't
come
without
its
issues
like
no
one's
saying
it's
a
panacea
and
that
you
should
just
use
open
source
and
it's
fine?
No,
there
are.
There
are
real
considerations
with
of
illegal
or
longevity
or
support
ability
or
end
of
life
and
LTS,
and
all
these
type
of
things,
different
customers
and
different
applications
have
different
needs
and
requirements,
but
who
better
to
try
and
help
move
that
needle
so
to
say
then
than
us,
and
so
we're
gonna
try.
And
this
is
something
that
we're,
but
that
we're
looking
to
do
and
when
you
know.
A
Frankly,
as
I
said,
we
want
to
deliver
great
solutions
to
our
customers,
saying
we
can
build
a
spinnaker
or.net
or
applications
that
serve
these
application
workload,
types,
whether
it
be
micro
services
or
whatever
it
might
be,
and
we
can't
afford
to
build
all
of
those
workloads
ourselves.
We're
not
the
biggest
team
in
the
world
and
it's
and
there's
already
fantastic
solutions
to
a
lot
of
those
things.
It's
just.
A
Form
groups
so,
for
example,
the
node
LTS
is
an
example
of
that
node
LTS
wasn't
put
together
by
and
managed
by
the
same
people
who
build
node
XE
was
put
together
by
a
different
group.
They
work
very
closely,
obviously,
and
they
have
a
nice
continuous
cycle
and
a
very
predictable
cycle
of
when
node.
You
know
current
versus
no
LTS
moves,
but
the
policies
are
very
straight
forward,
they're
very
predictable,
but
the
key
point
is
that
node
LTS
is
effectively
managed
by
a
different
group
than
the
node
sort
of
current
release
and
that's
an
example.
A
In
my
mind,
of
like
an
eve
of
a
third
phase
had
beyond,
there
are
the
phase
that
I
like
to
think
they
were
entering
now.
This
second
phase,
where
we
try
and
really
integrate
more
open
source-
and
you
know,
figure
out
ways
to
help
that
open
source
that
we're
integrating
with
into
our
default
experiences.
So
I
hope
some
of
those
things
resonate.
I
understand
that
some
of
those
things
might
you
know
some
people
might
have
some
feedback
and
some
some
issues
with
some
of
those
things.
B
A
I
mean
I've
seen
a
bunch
of
feature,
questions
I've,
seen
a
bunch
of
people
asking.
They
would
like
to
hear
more
about
stuff
coming
in
three
hours.
Mm-Hmm
raise
the
components
the
Sham
Co
is
asking
about.
Some
people
have
some
questions
as
they
relate
to
if
a
snake
or
three
is
only
going
to
run
on
their
core
three.
What
does
that
mean
for
some
of
the
components
that
we
might
use
on?
A
Other
platforms
today
stated
Microsoft
that
extensions
will
continue
to
target
net
standard
in
300
and
thus
you'll
be
able
to
use
them
on
all
the
Nets,
because
those
libraries
are
very
sort
of
BC
Elish
and
a
lot
of
people
like
to
take
just
the
bits
they
like
and
use
them.
I
think
Orleans
uses
a
bunch
of
that
stuff.
The
azure
functions
infrastructure
is
built
on
the
generic
host
and
a
lot
of
that
same
infrastructure,
and
so
that
makes
a
lot
of
sense
but
yeah.
So
I
can
there's
a
question
here.
Let
me
have
a
look.
A
Or
I
can
just
go
to
when
so
someone's
asked
when
is
in
process
net
core
in
is
official.
That's
Dane,
Watson,
that's
in
2
2,
so
2,
2,
3
b3
has
the
default
experience
in
Visual.
Studio
2018
was
the
2017
15.9
preview,
for
is
that
new
to
to
applications
run
on
is
Express
in
process,
and
thus,
when
you
deploy
the
one
in
is
in
process.
So
that's
part
of
the
to
to
release
the
in
process
stuff,
the
Jason
stuff
or
the
other
thing
that
was
announced.
A
I
didn't
mention
the
block
I
didn't
mention
talked
in
the
blog
post
was
the
there
was
announcing
about
the
future
of
Jason
and
Nicko
3,
and
so
a
very
similar
thing.
You
know
Jason
Garnett's
been
around
for
a
very
long
time
as
all
and
obviously
is
served
the
dot
that
community
very
well.
But
there
is
a
desire
now
to
to
a
couple
of
things.
One.
The
core
of
dotnet
should
have
fantastic
Jason,
api's
of
some
sort,
and
it
just
doesn't.
A
Today
we
just
don't
have
you
know,
Jason
is
ubiquitous,
it's
used
everywhere
and
dotnet
does
not
have
Jason
in
its
core.
Today,
most
people
use
Jason
down
there
as
a
result
of
that,
a
spinet
call
today
is
a
shared
framework,
actually
uses
Jason
net.
It
takes
a
dependency
on
Jason
dotnet.
So
if
you
use
asp.net
core,
you
have
to
use
Jason
net,
you
can
really
avoid
it.
It's
in
your
graph
either
way
right.
A
Even
if
you
don't
call
any
of
the
API,
is
it
used
a
snare
and
you
replace
the
Jason
format
or
do
something
else.
Jason
Arnett
is
in
your
graph.
So
if
you
do
want
to
use
Jason
donate
for
something
you
have
to
at
least
use
the
version
that
we
stipulate,
because
if
you
use
a
version
lower
than
that
you're
likely
going
to
break
us
and
that
had
does
cause
problems
for
customers,
we
had
that
feedback
very
quickly
after
we
made
that
change
in.
A
A
You
know
isolating
assembly,
loading
and
unloading
is
a
very
difficult
problem
and
that's
also,
incidentally,
something
that
we're
trying
to
solve
in
dotnet
caught
three
by
introducing
a
new
application
model
API
that
allows
you
to
load
assemblies
into
an
individual
context
and
then
use
them
in
that
context
and
then
throw
them
away
again.
So
that
is
one
of
the
things
that
having
Jason
on
net
baked
in
effectively
to
the
to
the
framework
causes
a
problem
with.
A
Just
because
we're
adding
JSON,
API
sort
of
low-level
fast
span
based
jason
api's
and
don't
make
or
three
doesn't
mean
you
can't
use
jason
Donaire
doesn't
mean
we
won't
ship
Jason,
don't
net
integration
packages,
we
will,
they
will
still
be
adjacent
net
based
MVC,
Jason
formatter,
for
example,
and
it's
just
that
that
would
be
in
a
package
and
you
can
add
it
and
then
you
can
just
use
it,
but
the
default
Jason
formatter
that
is
based
in
the
framework
itself
will
use
the
lower-level,
simpler,
API
and
so
yeah.
You
don't
really
lose
anything.
A
The
original
version
of
web
hooks
to
really
warrant
the
investment
required
to
port
that
over
on
the
team,
but
we
looked
at
usage
numbers.
We
looked
at
downloads.
We
looked
at
number
of
people
asking
as
a
concrete
ask
or
citing
that,
as
a
blocking
reason
why
they
couldn't
move,
and
it
was
just
frankly
too
low
compared
to
all
the
other
things
that
are
important,
so
it
is
somewhat
zero-sum.
We
can't
do
everything
we
understand
that
some
folks,
like
the
web,
hooks
API
and
they
use
it.
It
was
never
actually
built
by
the
asp.net
team.
A
It
was
built
by
a
different
group
and
then
kind
of
donated
to
the
age
of
garnett
team,
and
so
it
just
hasn't
made
it
to
the
top
of
the
list.
It
is
a
candidate
for
the
I
mean
I
would
I
would
offer.
It
is
probably
good
candidate
for
someone
or
a
group
of
people
from
the
community
to
just
do
a
straight
port
over
so
not
try
and
rewrite
it
or
anything,
but
just
just
try
and
get
it
working
on
top
of
the
the
newer
primitives
and
the
newer
patterns
in
a
spinet
core
MVC.
A
The
json
library
is
currently
announced
will
be
in
dotnet
core
3.
The
way
that
the
dotnet
standard
rationalisation
sort
of
process
works
is
that
they're,
very
hesitant
to
just
introduce
new
api
is
in
a
new
version
under
standard
then
tell
everyone
they
have
to
implant
them.
The
general
approach
is
that
a
framework
will
introduce
a
new
api
and
release
it
first
and
then,
once
it's
establish
itself
and
been
baked,
it'll
go
through
the
process
of
being
included
into
a
future
version
of
dr
standard,
for
example,
like
span,
which
is
just
being.
A
A
It'll
work
on
Linux
as
well
port
to
work
on
net
core
will
work
on
both
it's
one
of
the
it's
one
of
the
rare
it's
one
of
those
sort
of
modular
parts
of
the
bringing
wind
forms
and
WPF
to
dotnet
cause.
That's
all
windows
only
obviously,
but
as
part
of
bringing
that
over
ef6
will
come
over,
because
so
many
applications
sort
of
require
the
ef6
model
for
their
desktop
apps.
But
that
code
has
no
intrinsic
title
windows,
so
that
code
will
just
run
and
be
supported
on
all
the
platforms.
A
The
package
reference
comes
with
all
these
connotations.
You
assume
it's
gonna
behave
a
particular
way
now
NuGet
packages
when
you
reference
them,
typically
end
up
putting
dll's
in
your
application
output
right,
that's
how,
when
you
get
back
works,
it
delivers
the
dll
to
you
and
then
you
take
that
deal
with
you.
When
you
publish
the
application,
you
also
specify
a
version
and
that
version
of
the
package
gets
reasoned
about
with
any
other
instance
of
that
package.
A
That
appears
in
your
graph
because
remember
we
have
transitive
references
and
all
all
your
packages
in
the
graph
are
listed.
Sometimes
you
reference
something
else
that
then
references
the
same
thing,
but
it
references
a
different
version
and
that
conflict
resolution
is
managed
by
nougat
and
there
are
rules
that
determine
which
version
am
I
going
to
use,
because
I
can
only
have
one
in
my
graph.
A
I
can't
have
two
versions
of
the
same
library
in
my
graph
at
the
same
time,
and
that
can
get
very
confusing
when
say
I
reference,
your
library,
John
and
you
want
Jason
net
ten,
but
in
my
application,
I
have
already
put
Jason
net
at
version
nine
in
my
project
file.
So
in
my
project
file,
I
see
John's,
great
library
and
I,
see
Jason
dotnet
right
and
I
have
version
one
of
your
library
and
version
9
of
Jason
net.
But
your
your
library
says
at
once:
Jason
net
10,
which
version
isn't
it
actually
gets
loaded
right?
A
Do
you
know
that's
a
pop
quiz,
yeah
hoisting
right?
Do
we?
Is
it
gonna
take
the
newest,
so
that
is
the
natural
answer.
Is
you
would
think
it
would
take
the
newest?
But
the
answer
is,
it
depends
in
this
case
it
won't
it'll,
take
the
lowest
because
of
a
rule
called
nearest
wins,
which
is
you
have
an
explicit
reference
to
taste
in
a
in
your
project,
which
is
closer
than
the
reference
to
Jason
net.
A
That
is
transitively
brought
in
by
fact
that
I'm
referencing,
your
library
and
so
yours
acts
as
an
override,
as
in
the
one
in
the
project
problem.
Is
that
will
usually
break
your
library
because
you
were
expecting
version
10,
which
probably
means
that
you're
using
some
version
10
thing,
and
when
does
that
error
turn
up?
A
It
turns
up
when
you
run
the
application,
and
you
just
play
your
library
when
I
call
int,
it
tries
to
use
some
JSON
net10
feature
and
you
get
a
type
load
exception,
or
a
member
missing
exceptions
like
the
worst
possible
things
and
then
you're
in
DLL
hell,
because
you
have
no
idea
why.
Why
is
the
DLL
with
a
compiler
worked?
Why
is
it
that
it
can't
find
the
method
at
runtime?
A
That's
why,
and
so
that's
the
bigger
problem
is
that
we
want
to
ensure
that
if
you're
gonna
reference
a
framework,
that
is,
by
definition,
something
that
has
to
be
there
on
the
other
side,
for
my
application
to
run
my
app
runs
on
a
framework,
the
framework
falls
into
me,
a
library
I
called
into
so
it's
expected
that
I
bring
the
library
with
me.
That's
generally
the
definition
of
those
terms
that
we
use
okay
and
so
a
shared
framework
in
the.net
core
world.
A
You
target
a
shared
framework
on
top
of
the
TFM
that
you
target,
which
is
confusingly
called
a
target
framework
mónica,
because
it
is
also
a
framework.
I
target
this
sort
of
extra
shared
framework,
but
I
do
it
by
a
package
reference
I'm
cleared
of
crossing
the
streams
I'm
crossing
the
world,
and
it
becomes
very
difficult
to
reason
about
what
assembly
will
be
used.
A
What
do
I
need
on
the
machine
for
that
to
application
to
run
what
are
the
ways
that
it
can
fail
and
then,
when
you
add
things
like
patching
and
servicing
role
for
policy
where
I
might
target
shared
framework
version,
2.1,
oh,
but
if
I
run
on
a
machine
that
has
to
dot
1.3,
I'm
gonna
run
onto
dot
1
2
3.
That's
how
you
get
automatic
updates
when
you're
running
on
a
shared
framework,
ok,
otherwise
you
have
to
rebuild
and
republish
your
application.
A
Every
time
we
do
a
security
release,
and
so
those
confusions
have
led
us
to
say
you
know
what,
if
it's
not
a
package,
if
it's
actually
a
shared
framework,
you
need
a
different
reference
type
and
so
in
300
we'll
introduce
a
different
reference
type
in
your
project.
It
will
say
framework
reference
instead
of
package
reference
and
that
has
different
rules.
You
can't
put
a
version
on
a
framework
reference.
A
B
B
Individual,
like
I,
can
tailor
my
application
pull
in
which
ones
and
then
we
got
meta
packages
which
kind
of
say
like
hey:
let's
make
it
simple
and
pull
in
most
of
the
ones:
he'll,
probably
use
and
tooling
lights
up,
and
all
that,
but
I
could
go
through
and
kind
of
tailor
all
my
new
get
packages
if
I
want
them
and
now
with
this
it
feels
kind
of
like
we're,
moving
more
full
circle
to
monolithic,
install
and
do
I
lose
anything
here
as
a
developer.
So.
A
I
think,
it's
fair
to
say
things
change
and
we
listen
to
feedback,
and
so
we
tried
we.
We
certainly
set
out
with
a
particular
premise
in
the
beginning
six
five
six
years
ago
and
then,
as
we
saw
those
things
used
by
customers,
we
saw
where
those
paradigms
sort
of
had
edges
or
broke
down
completely
and,
for
example,
the
proliferation
of
packages.
A
When
you
build
a
new
framework-
and
we
lay
it
at
the
way
that
we
did
for
very
good
reasons,
and
but
you
literally
end
up
with
hundreds
of
packages,
a
lot
of
the
problem
customers
face
was
like
I,
don't
even
know,
I
know,
I
know
what
API
I
want.
I,
don't
even
know
what
package
it's
in
and
we
tried
to
solve
some
of
those
things
with
the.
A
A
That
we
talked
about-
and
it's
more
about,
how
do
you
reason
about
that
like
who
wins
like
your
natural
answer,
isn't
off
their
natural
inclination?
Isn't
the
right
answer
a
lot
of
the
time
and
that's
just
too
confusing?
Thirdly,
how
do
you
optimize
those
you?
Would
you
want
to
optimize
the
application
to
startup
faster?
A
You
start
the
application,
there's
no
cash
for
that,
and
so
that
is
a
cost
and
so
think,
whereas
frameworks
can
be
cross-gender,
they
can
be
pre
jittered
because
you
install
them
on
the
machine
for
the
particular
machine
and
that's
a
fairly
well
understood
technology.
We
understand
those
drawbacks,
we
understand
it's
its
benefits
and
we
understand
how
to
circumvent
some
of
its
drawbacks
with
things
like
tea
compilation
that
we're
introducing
as
well,
it
don't
net
core
that
you
can
enable
that
helps
get
back
some
of
the
steady-state
performance
or
what
we
just
call
throughput
after
that.
A
The
cross
chain
can
take
away
because
Prakash
Jenner's
optimized
prejudging
is
optimized
for
speeding
up
the
startup
code,
but
it
can't
make
certain
optimizations
that
can
benefit
how
fast
your
app
runs
at
runtime.
But
tier
compilation
can
do
that
when
it
sees
that
those
code
paths
are
called
while
the
app
is
running
and
it
can
reap
compile
those
methods
and
those
members
after
the
application
is
running
to
get
all
that
performance
back
and
so
our
understanding
of
what
the
right
trade-offs
of
evolves
as
customers
use
the
the
technology,
and
we
see
the
feedback.
A
We
see
the
problems
that
customers
run
into,
and
so
all
the
things
that
you
mentioned
were
steps
that
we
took
when
we
adjusted
those
trade-offs.
We
were
like
well,
we
thought
that
full
modularity
and
pay-as-you-go
was
the
right
trade-off
to
make.
It
turns
out
that
the
vast
majority
customers
just
found
it
too
difficult
to
figure
out
where
those
things
were
and
having
a
meta
package
that
brought
in
all
the
api's
was
a
much
better
experience,
because
then
I
just
have
all
the
api's
available
to
me.
A
The
problem
with
that
or
the
trade-off
was
that
well,
if
a
tomato
package
now
I'm
deploying
200
assemblies
into
my
bin
folder,
that's
not
good,
because
now
I
lose
all
my
paper
play.
So
what?
If
we
took
that
that
shared
that
meta
package
and
turned
it
into
a
thing
called
a
shared
framework
and
we
required
that
to
be
on
the
target
machine
now,
my
application
is
vastly
smaller.
A
It's
just
my
application,
DLL
and
static
resources,
which
is
why
in
2.1
to
where
we
had
this
thing,
called
the
runtime
store
that
we
only
lived
for
one
version.
I've
got
much
smaller,
so
my
two
one
applications
are
much
much
much
smaller
to
deploy
than
my
1x
applications
and
I
get
that
servicing
capability
as
well,
so
that
when
a
new
version
comes
out
to
point,
1.5
I
installed
that
version
of
the
shared
framework,
which
now
includes
a
spinette
core
bits
and
all
my
applications
as
soon
as
they
restart
that
I
have
to
recompile
them.
A
I
don't
have
to
republish
them.
Get
those
bug
fixes,
ok,
which
is
why
the
servicing
bar
is
so
high,
because
we
want
to
ensure
that
you
don't
break
people,
but
because
it's
not
net
core.
You
also
get
side
by
side.
So
if,
for
some
reason
you
really
do
need
to
stick
on
a
particular
version,
you
can
you
have
that
option.
Where
you
don't
have
that
option,
we've
done
the
framework.
A
You
can
do
a
self-contained
deployment,
which
means
everything
does
come
with
your
applique
and
we
have
emerging
technologies
like
the
il
linker
or
the
module
linker
that
enables
you
to
say
well
I
reference,
the
framework,
but
I
don't
need
it
all
right!
I,
don't
actually
need
it
all
to
run
my
application.
A
So
please
trim
out
everything
we'll
link
away
everything
I,
don't
use
that
technology
is
something
we're
looking
to
bring
into
300
and
beyond,
so
that
you
really
can
at
customer
choice
at
the
application
level
choose
what
is
the
best
set
of
trade-offs
for
this
application?
The
reality
was
the
way
that
we
architected
in
the
beginning
and
1o
was
a
set
of
trade-offs.
It
was
a
set
of
trade-offs
that
we
fought
on
everybody
and
over
time
what
we've
done
is
really
said.
A
No,
this
is
what
we
think
is
the
default
set
of
trade-offs
that
applications
should
have,
but
we
don't
want
to
shut
out
the
other
options
so
that
there
will
be
other
ways
of
ensuring
that
you
don't
lose
smaller
applications
or
the
ability
to
do
side
by
side
or
anything.
It's
just
that
we
use
different
technologies
to
do
that,
using
NuGet
and
packages
to
do
that
at
the
scale
of
hundreds
and
hundreds
of
modules
that
may
version
independently,
for
example,
was
just
too
much
to
really
deal
with.
Ok,.
A
B
A
Might
actually
try
and
get
the
blogpost
ready
for
next
week,
so
I
can
talk
about
sort
of
did
the
initial
overview
of
what
we
call
the
big
walks.
The
big
features
coming
in
three
are
the
things
that
we've
got
of
penciled
in
to
our
plan
and
then
we're
now
going
off
sunny,
create
work
items
for
so
we'll
do
that?
How
about
we
do
that
do
that
next
week?
Ok.
A
A
That
will
help
us
level
out
the
audio
I
mean
we
also
have
a
whole
mixing
board
under
the
table
here
that
all
the
audio
is
going
through,
which
I'd
be
surprised
if
it
doesn't
have
a
similar
feature,
but
if
we
can
fix
it
in
software,
then
by
all
means
we
could
try
that
it's
just
finicky
like
we
don't
spend
hours
and
hours
and
here
trying
to
tweak
all
this
stuff,
but
I
am
trying
to
make
it
as
good
as
we
can
for
everyone,
though.
So
all
right,
we
will.