►
From YouTube: Bing runs on .NET Core 2.1
Description
Mukul Sabharwal chats with Jon Galloway about the Bing.com’s move to .NET Core 2.1, including some huge performance and deployment agility gains.
A
Hi
this
is
John
Galloway
and
today
I'm
talking
to
McCall
from
the
Bing
team
and
McCullough,
you
wrote
a
really
cool
blog
post
recently,
where
you
talked
about
how
the
performance
impact
and
all
kinds
of
other
great
impacts
from
running
on
dotnet
core
to
one.
Can
you
give
me
just
an
idea
of
the
the
sigh
you
know
the?
How
how
busy
Bing
is
I
mean
how
what
kind
of
traffic
you're
you're
processing
here
yeah.
B
A
Okay,
so
I
always
think
it's
great
when
I'm
talking
to
people
to
get
it.
You
know
when
I'm
talking
to
customers
to
tell
them
that
large
implementations
of
dotnet
or
you
know
people
are
using
dotnet
core
on
large
production
instances,
and
this
is
a
really
cool
one.
So
one
thing
you
call
out
right
at
the
top
of
this
post
is
the
idea
of
ready
to
run
images
and
I.
Don't
think
that's
that
well-known?
Can
you
explain
what
that
is?
Yeah.
B
So
ready
to
run
images
are
this
version
file
format
that's
available
on
dotnet
core,
basically
allows
you
to
pre,
compile
your
assemblies
into
both
native
and
manage
code
in
the
same
file
which
allows
you
to
basically
have
this
ready
run
experience.
You
have
managed
code
that
gets
jittered
usually,
but
when
your
images
are
ready
to
run
that
are
essentially
ready
to
run
when
your
program
starts,
which
is
very
useful
for
if
you
have
a
large
application
with
many
assemblies
and
a
lot
of
managed
code,
it
really
helps
startup
performance
and
also
impacts
your
working
set.
B
A
B
The
the
key
part
of
ready-to-run
images
and
dotnet
core
is
that
we
did
have
previous
technologies
like
engine
on
dotnet
framework,
but
they
always
a
required
admin
privileges
on
the
actual
machine
that
you
need
to
Engen
on
and
also
the
fact
that
it
had
to
be
done
on
the
exact
machine.
So
if
you
have
five
thousand
machines,
that
mossis
happens,
five
thousand
times
yep.
A
Okay,
so
next
this
is
awesome
seeing
this
chart
here
this
you,
you
showed
a
thirty
four
percent
improvement
from
from
deployment
from
upgrading
to
dotnet
core
to
one.
So
previously
you
had
both
dotnet
framework
for
seven
to
and
dotnet
core
to.
Oh,
so
just
that
that
bump
two
to
one
was
a
thirty
four
percent
improvement
overall.
B
Yeah,
so
we
basically
when
we
migrated
our
code,
we
were
still
running
on
net
four,
seven
two
and
then
you
know
we
would
switch
back
between
four
seven,
two
in
two
Oh,
and
so
we
had
both.
We
saw
both
sides
of
four
seven
two
and
two,
oh,
and
when
we
upgrade
to
two
point,
one
that
was
phenomenal.
34
percent
improvement.
That's
right!
So.
A
I
love
how
you
went
through
and
called
out
detailed
issue
or
like
features
and
also
specific
pull
requests
on
some
of
these,
and
you
showed
why
your
performance
got
better.
So,
like
any
favorites
here,
I
mean
I,
I,
always
loved
things
like
vectorization
and
and
looking
at
how
that
kind
of
bubbles
all
the
way
up.
The
stack
yes.
B
B
My
favorite
I
have
to
say
is
the
vectorization,
because
it
actually,
you
know,
had
a
major
impact,
but
this
my
my
other
favorite
one
is
the
combination
of
work
done
by
Microsoft,
employee
and
Andy
Ayers,
and
an
open-source
contributor,
well-known
Ben
Adams,
where
they
had
D
virtualization
and
how
that
impacted,
when
you
did
it
for
certain
default
equality,
comparison
areas,
that
was
you
know,
it
was
a
great
sort
of
synergy
between
Microsoft
II's
and
open-source
desolate.
I
would
say
you
know
that's
one
of
my
favorites
and
it's.
A
It's
really
neat
in
as
part
of
this.
My
understanding
is
that
you
had
specific
requests
and
you
work
through
the
public
github
thing
to
say:
hey,
we'd,
love,
this
sort
of
performance,
improvement
or
change,
and
then,
as
part
of
that
collaboration,
this
shipped
as
part
of
dotnet
core
to
one
and
helps
everyone
out
right.
That's.
B
Right,
one
of
the
ones
that
I
that
I
contributed
and
you
know,
sort
of
open
to
pull
requests
an
issue.
Was
this
one
with
calling
direct
and
it's
it's
because
we
generate
that
kind
of
code,
so
you
can
imagine
as
an
open
source.
If
you
have
a
particular
kind
of
code
that
you'd
like
optimized,
it's
it's
really
great.
You
can
just
go
in
and
contribute
and
that's
what
we
did
with
the
help
of
the.net
team
as
well.
So
it
really
overall
was
a
great
experience.
Operating
an
open-source
is
probably
one
of
the
main
reasons.
B
B
B
One
is
this
idea
of
self-contained
apps,
so
for
us
we
use
this
idea
of
self-contained
apps
and
we're
able
to
basically
have
the
dotnet
core
runtime
be
a
part
of
our
application
deployment
so
which,
if
you
think
about
it
is,
is
extremely
cool.
You
just
have
your
app
sitting
right
besides,
it
is
all
the
core
CLR,
the
GC,
the
JIT
everything
there.
So,
if
you
think
from
a
person
a
perspective
of
you
know,
how
can
you
isolate
things?
It's
really
cool
you
on
day,
one.
B
You
have
this
application
running
on
a
framework
on
day
two,
you
upgrade
it
with
dotnet
core
sitting
right
beside
your
app,
and
so
when
dotnet
core
2.1
comes
out
for
us.
It's
a
change
in
the
CS
project,
literally
a
change
in
the
NuGet
package.
We
made
one
character
change
and
we
were
able
to
deploy
dotnet
core
2.1
two
days
after
and
that
two
days
is
just
because
of
some
additional
validation
we
had
to
do
so.
That
was
really
awesome.
That's.
B
So
this
is
another
one
of
these
things
where
the
ecosystem
really
helped.
We
with
done
at
core
2.1.
You
also
get
broadly
support
in
the
core
FX
libraries,
so
we
actually
use
that
and
were
able
to
get
big,
comm
broadly
support,
which
was
phenomenal.
So
not
only
did
we
get
all
these
performance
improvements,
our
response
eyes
also
shrunk
a
little
bit
because
of
using
broadly
so.
That
was
also
pretty
phenomenal.
Wow.