Conditional Breakpoints [4 of 5] Beginner’s Series to Visual Studio Tooling for Unity Developers

>> [MUSIC] My name is
Charles. In this video,
I'm going to show you how to
use conditional breakpoints
to focus on the data and
values that actually matter.
That way, you can debug
smarter and fix bugs faster.
More often than not, your games
most crucial features are
the ones that present the
biggest debugging challenges.
Take this project, for example.
Spawning is one of its key mechanics
and I've tried to
improve that by writing
code that changes the SpawnRate in
response to the player's skill level.
The idea is that enemy
should spawn faster
when the player is doing well
and slower when the
player is lagging behind.
To achieve this, my logic
modifies an animation curve
that represents enemy
SpawnRate over time.
Here, the x-axis represents time
and the y-axis represents SpawnRate.
This graph represents a
linear progression in
which enemies will spawn
faster as time progresses.
However, that's just a
static, hard-coded example.
In reality, our graph will
fluctuate as the player plays
and there's no telling what it will
actually look like at runtime.
If it's working as expected,
the players should be
met with a challenging
yet manageable flow of enemies.
However, somehow I've
introduced a bug that causes
the SpawnRate animation
curve to fall below zero,
which results in a ton of
enemies being spawned.
That's no fun for the player
and especially no fun for me,
the developer who now
has to figure out
what in the world has gone wrong.
Looking at the code
that's responsible
for updating the animation curve,
we can see that it uses
an algorithm that applies
some modifiers to a
configurable base SpawnRate.
The key modifier here is
the difficulty modifier,
which is used to increase the
time in-between each spawn.
This is really good
information to work with,
but I'm not really sure where
to begin my debugging process.
The problem is that algorithms
are not my strong point
and I have no idea
what could be causing
the SpawnRate to spin so
wildly out of control.
I'll need to do some debugging.
Now, the standard approach is
to use debug.log statements
to get more information
about what's happening.
However, in this case,
we've got a lot of noises,
there's just too much
happening in the scene.
We could add some logic
to make our logging a
little more intelligent,
but then we just have a
bunch of debug code peppered
throughout our logic
and no one wants to maintain that.
Instead, we're going
to use a feature of
the Visual Studio
debugger that'll help us
quickly get more information
without all of this extra code.
Let's start by adding
a normal breakpoint on
the line right after
SpawnRate gets assigned.
Then let's attach
Visual Studio to Unity.
Perfect.
Now, switch back to
Unity and hit "Play".
This will cause the debugger
to immediately cause
the execution of our code on our
breakpoint just as expected.
Now that's helpful
because as we've covered
in our other videos about debugging,
we'll be able to inspect any
and all variables that
are currently in SQL.
But I'm not really interested in
inspecting those variables just yet.
At this point in our games lifecycle,
SpawnRate is being set
to a reasonable value,
it's working exactly
as I expect it to.
While I could poke around,
I don't know if I'd be able to
discern anything of importance.
What I really care about
is inspecting the code
when the bug occurs and
only when the bug occurs.
That's where conditional
breakpoints come in.
Conditional breakpoints
are a feature of
the Visual Studio debugger.
They allow you to pause
the execution of your code
when certain conditions
have been met.
This can give us a great deal of
additional control over
our debugging process.
Let's see it in action.
Back in Visual Studio.
Let's modify our existing
breakpoints so it pauses execution
when SpawnRate dips below
a certain threshold.
For example, a threshold that
we deemed to be unacceptable
or too dangerous for the player.
To do that, all we have to do is
right-click on the breakpoint
and then select "Conditions"
from the context menu.
This will present a breakpoint
settings block that appears
just below the line on which
the breakpoint is set.
From here, we have a couple
of options to choose from.
Let's expand the first drop down.
Our options are conditional
expression, hit count, and filter.
Conditional expressions represent
any logical condition
that you can think of,
so long as the values you
reference are in scope.
When using conditional expressions,
the breakpoint will be
triggered when your expression
has been satisfied or when
a value has been changed.
For example, I can
reference SpawnRate so that
execution pauses whenever
its value changes.
Hit count triggers your
break point whenever
the line has been executed
a certain amount of times.
This is great for loops that you
suspect have gotten out of control
and are iterating more
times than they should.
Finally, the filter option
triggers your break point
when specific low-level
conditions have been met.
There are a number of
predefined filters available,
such as machine name, process ID,
and thread name that
you can use to restrict
your breakpoints to select
devices, processes, or threads.
In our case, we don't need
anything complicated.
We'll just use a
conditional expression.
Since something is
causing the spawner
to spawn enemies way too quickly,
I suspect that SpawnRate is being
set to a ridiculously small number.
Let's confirm that suspicion by
adding a condition that triggers
the breakpoint when the value
of SpawnRate drops below 0.5,
then we can examine the other values
and try to determine what's going on.
This condition is possible
because SpawnRate
is in the same scope
as the breakpoint.
You may recall from
our debugging basics
video that you should
take care to add
breakpoints to the lines
of code for all of
the variables you want to
inspect are accessible.
In our case, SpawnRate is
a variable that's local
to the function where our
breakpoint is currently placed.
So we're good to go.
Let's play the scene until
our breakpoint is triggered.
[MUSIC].
Great. Our conditional
breakpoint worked.
The execution of our code
is pause at the point
where SpawnRate has reached
an unexpected value.
Now we can figure
out what's going on.
Again, I'm terrible with algorithms.
Hopefully, the solution
will be simple.
Let's analyze each variable
that's used in our dynamic
SpawnRate algorithm.
Base SpawnRate is a field that
can be set in the inspector.
It represents the base
SpawnRate of the spawner.
It should be set to a moderate value,
which it looks like it is.
Next, spawn enemies is an instance of
a scriptable object that
holds a list of game objects.
Here we're adding the count
to the base SpawnRate
in order to increase the
time between each spawn.
That way, the game becomes easier
when there are more
enemies in the scene.
Moving on, difficulty
modifier is another field
that can be set in the inspector.
Its job is to tune down the impact
that enemy count has
on the base SpawnRate.
The lower the value, the
harder the difficulty.
In this case, it looks
like it's way too low.
In fact, a negative value should
not be allowed here at all.
This is a common problem that happens
when you expose
properties in the editor,
especially when those properties have
an effect on your
games key algorithms.
Users will always
find a way to provide
values that fundamentally
break your logic.
That being said, being able to
parameterize your component
is extremely important
because you want to be able
to hand off tasks like
tuning difficulty to game
designers wherever possible.
Instead of restricting this
property to fix the bug,
we're going to make a
couple of quick changes
to guard against bad user input.
The first is the range attribute.
Range is a Unity specific
attribute that limits
the value of a property in the
editor to a predefined range.
Let's limit difficulty modifier
to a value between 0.1 and 1.
Perfect. Now, our game designer
won't be able to input
a game breaking value.
That's a great start, but we
still need one more check.
A dynamic SpawnRate algorithm
partially depends on elapsed time.
That means that given enough time,
SpawnRate will eventually dip
down into an unacceptable range.
Luckily for us, the
solution is as simple as
clamping SpawnRate between
two acceptable values.
This will allow us to provide
minimum and maximum values.
That's it, our game
is back to normal.
More importantly, we've limited
the ability for our game designer
or anyone else who modifies
the spawner component
to break our logic.
It was all thanks to
conditional breakpoints
in the Visual Studio debugger.
Without them, we either have to sift
through tons of log statements
or manually pause and continue
the execution of our code until
we reach the broken state.
Conditional breakpoints gave
us the ability to place
a breakpoint that pause
only when we needed it to,
which helps us close
our feedback loop
and dramatically speed up
our debugging workflow.
Best of all, it works the same way
across all Visual Studio products.
Whether you're using Visual Studio
for Mac or Visual Studio code,
be sure to take advantage of these
powerful time-saving features.
[MUSIC]

Connect your application to Azure using Visual Studio 2022

>> [MUSIC].
>> Hi everyone. My name is
Angelos and I'm a PM for.Net.
Today we're going to look
at how Visual Studio helps
me integrate my application
with Azure services.
We're going to look at how to get
our Kobe's configured correctly.
We're going to look at how to
emulate Azure services locally,
during local debugging,
we're going to look at how to
publish our application to Azure.
Finally how to deal
with the situation
of maybe I want to
connect my application
to different instances
of services for
different environments.
Let's jump right in.
Here I am in the
connected services tab,
and I can get back here by
just double-clicking on
the Connected Services note in
Solution Explorer at anytime.
This tab is split into two parts.
The bottom part is called
Service References,
and that helps me connect
my application to OpenAPI,
gRPC and WCF endpoints.
We're not going to spend
time on that today.
We are going to focus
on the top part,
which is service dependencies.
That helps me connect to Azure
services and SQL Server.
Right now, my application
is not connected to
anything and it says so right here,
and I'm going to click "Azure
Service Dependency" to get started.
Let's take a look at
some of my options here.
The first two items from the list
are referring to
Application Insights.
The first option is a local
only option that is only
available during F5 when I'm
debugging my application.
The second option is
letting me connect to
an actual live instance
of Application Insights.
Now the reason why on this screen,
I'm getting some
local options is that
because when I'm configuring
things to connected services.
I'm configuring how my application
is going to behave during F5.
Though, some of these options
are not going to make
a lot of sense doing published,
but they are not going to be there.
Following on, on the list and
next few options are
about Azure Storage.
The first two are two local
on the emulator options.
One of them is going to
run the Azurite emulator,
as it's called in a container,
the other one is going to
run the Azurite emulator
just straight up on the machine.
Finally, the third
option is to not let you
connect to Azure Storage,
real life instance.
Then moving down the list,
we have Azure Signal R Service,
which is again connected to a
real life service in Azure,
we have a local option for dealing
with applications secrets.
You can use the secrets
translation file,
which is the default way of keeping
application secrets outside
of your source repo.
Then we have the ability
to use Azure Key Vault and
actually Visual Studio
is smart enough to
let you use Secrets
Rotation locally,
and when the time comes to publish,
to switch that out
for using key vault,
we'll see how to do that later.
Then we have the ability to connect
to Azure app configuration,
which is just another
way of centralizing
all your application
configuration and
even integrate with keyboard.
That's pretty cool.
Then we have three
options for SQL Server.
SQL Server Express LocalDB,
that's a local only option,
it's very popular for doing local
development with SQL Server.
Then we have Azure SQL database,
which is connected to a
live instance of Azure,
Azure SQL database online.
We also have the ability to connect
your application to SQL
Server database on-prem,
maybe you have an instance on your
local machine on the network.
Then we have two options
for Redit cache.
One is a local
emulation option again.
It's going to run in a container.
The other one is going to connect
to a live instance of Azure.
Finally we have Azure, CosmosDB,
and much of identity
platform that lets
you achieve authentication
through Azure Active Directory.
I'm going to keep
things simple here.
I'm going to configure
my application to connect to
SQL Server Express LocalDB.
I click "Next" and I get to give
a name to my connection string.
I'm going to say my
connection to SQL.
Here Visual Studio
is helping me manage
that application secret the
connection string value.
Ideally, I don't want
it in my code base.
I can either by default would've
been the user secrets file,
or it can even integrate
with Key Vault.
This is basically the
equivalent of me adding
independency to Key Vault and
then putting the value in there.
I just don't have to do that
manually, VS can do that for me.
I'm going to keep
things simple and use
my local user secrets file locally.
Now we get a little summary
page that is going to
tell me what is VS
doing on my behalf.
It's telling me it's
going to get the right
makeup packet is spin up,
put the value in the
right Secret Store.
Because it's SQL Server,
it doesn't need to be paid a
code-based anyway so that's nice.
I can just click "Finish".
It will give me a little summary
of everything that it did.
Now it's telling me that my
application is configured
correctly to talk to
SQL Server LocalDB.
Let's do that one more time, and now
let's add a connection to storage.
Now I could connect to live
Azure Storage instance,
but locally I want to emulate things
so I'm going to pick the
storage Azure emulator.
I'm going to click
"Next" I'm going to give
my connection string and much
low my connected to storage.
Same options with the application
secret, I click "Next".
In the summary page it's telling me
that it's going to do the
same things as before.
This now an extra
step to also prepare
my codebase to be ready to
consume The Azure Service.
Didn't need a physical server,
but I do need it for storage.
It's really nice that Visual Studio
will just take care of
all of that for me.
Just click "Finish" here,
get my little summary of
exactly what's going on.
Now my application
is configured with
very few clicks to consume
Azure Storage and SQL Server,
and I'm ready to write
my business logic.
Now at this point, I
can go to "Publish".
I can create a new
Published Profile.
Pick Azure and offset this
Linux as my deployment target.
Here, Visual Studio is letting me
manage all of my Azure resources
without leaving the ID.
If I have multiple accounts
that I'm logging with,
I can switch over to
the different accounts.
If I'm logged in with
multiple subscriptions,
I can change the subscription.
I can search for instances that
already exist and pick them.
I can group things
by resource group,
which is very helpful for people
who are going to keep everything in
the same resource group when it
comes to a flat list
by resource name.
Of course, I can always
provision new resources
without leaving the ID.
Now I don't want to
do that in this case,
I already have an instance created,
so I'm just going to pick it from
the list and click "Finish".
Visual Studio now has
a published profile that is
ready for me to use immediately.
If I want to, I can just click
"Publish" and visuals are just
going to be the right thing.
It's going to build the app
and publish it to App
Service successfully.
That's why the status
is ready to publish.
But I've already told Visual Studio,
that I am connected to
SQL Server and storage.
It's smart enough to
know that locally,
I'm connected to basically
emulation options,
the storage emulator and
the SQL Server LocalDB.
It knows that's not going to work,
that's not going to
be successful when
I'm deploying an
application to Azure.
Because even though publishes
successful and the application
will be there when it starts to run
and tries to access the resources,
it's not going to be able to, so at
the bottom of the page here we have
our service dependencies list.
Again, the same list as we've had
before in Connected Services tab,
we now have it in this
Published Profile.
VS is telling me that this is
good to go as soon
as I configure it.
I just need to hook it up to
an instance that is available
in that environment.
I just click "Configure".
It knows that Azure SQL database
is probably what I want to do so it
has filtered the list
and just slap on
pre-selected for me,
I can click "Next".
Now I'm immediately in select an
existing instance to connect to.
It's the most common scenario.
That's why we default into it.
But like I said, you
can always provision
new Azure instances
without leaving the ID.
Here I'm just going
to pick an instance
that I already have
and connected to it.
I'm going to keep my
connection string the same.
I'm just going to
provide the username and
password that I know I can use
to connect to this instance.
When I click "Next",
it's going to give me
a summary of what it's
about to do and I'm
going to click "Finish".
It's giving me a running summary
of what it's doing right now.
Now this connection has
been configured correctly.
All I have to do, is go to
the next one and do the
same thing for storage.
Again, I can provision
the new instance,
but I don't have to, I can just
pick an existing one right now.
I'm going keep the same
connection string name.
Of course, the
appropriate connections
in value is automatically
figured out by VS.
I don't even have to worry about it.
I can just click "Next". Little
something that's going to happen?
Click "Finish". Now my application
is all set up and correctly
configured around this environment.
Now when I do publish,
application is going to end up
in App Service successfully.
Once you start running,
is going to access
the appropriate connection
strings with the configuration.
My application will be
able to run successfully.
Well, that was fun.
I hope you guys had
fun with me as well and
learn something new.
We're constantly adding more
support for more integrations.
We are adding support
for more Azure services
and we're dying to
hear your feedback.
Let us know what you
think, Tweet at us.
Let us know through
developer community.
Just know that we're
always listening.
Thank you very much. Take care.

Connecting rural communities with affordable broadband

[MUSIC]
Just because you live in a rural
area doesn't mean you shouldn't
have the opportunity
to be connected.
[MUSIC]
>> I was about I would say ninth
grade year is where I began
taking college classes
through dual enrollment.
And that requires that
you upload papers and
assignments to the college as
well as to the high school.
The internet was terrible
at home, so I would have to
do my assignments really early,
like a whole month early.
>> He had to submit
a lot of his paperwork.
It's just gonna sit there and
just spin and spin and spin.
>> You know that
the deadline's coming and
you know you need more research
and you know it's not enough.
It's a struggle.
[MUSIC]
>> In the beginning of the
semester, one of the questions I
ask the students just a show of
hands, who has Internet access?
Typically just a few.
Right there, that tells me that
I have to be a little limited
in any kind of homework
assignment I give.
It's a handicap for
teachers in the 21st century.
I mean here we are.
Hands are kind of tied.
>> The homework gap is a major
problem for our region.
And the exciting part
is that Charlotte and
Halifax County are two pilot
areas are no longer gonna be
left behind in this
digital divide.
[MUSIC]
TV White Space is
a new technology that
the FCC has allowed
vendors to transmit
broadband connections wirelessly
over previously unused airwaves.
Rural markets specifically,
it is critical to have access
to that lower band spectrum that
allows Internet providers to
serve that last mile affordably.
>> The goal is by fall to have
about 250 connected and we're
hoping to have 1,000 families
connected soon after that.
>> It's gonna open the doors
to economic development and
it'll allow
the people in our area
to have access to
a world class education.
>> It was a dramatic increase in
productiveness and efficiency.
>> Dylan has a small antenna in
his home which is connected to
a TV White Space device,
turns on his laptop,
connects via WiFi.
>> I don't know the tech side.
All I know is it works.
[LAUGH]
>> Now that I have
TV White Space Internet,
I can use the cloud and
my grade actually shot up.
Going forward with TV White
Space I got high Bs and As.
>> This is where I grew up and
I love it.
I'm a country girl.
Let's train our kids so
they can stay home and
have that knowledge and then
they can bring it back here so
that our community can grow.
TV White Space held up very well
with my college application.
Once I graduate,
I will be going to attend Old
Dominion University in the fall
studying computer science and
very excited to go.
[MUSIC]

Creating a private extension gallery for Visual Studio

[MUSIC].
>> Hey everyone, I'm
Leslie Richardson from
the Visual Studio
extensibility team.
In this video, I'm going to
show you how you can create
your very own private gallery
in Visual Studio 2022.
Why even create a private
gallery? What even is it?
If you've ever written
an extension that you
didn't want to release to
the world publicly either via
the VS marketplace or
some other location,
and you only want it to
share it with a select group
of people like maybe your
team or your company.
Then a private gallery
allows you to do just that.
It's essentially a privatized
version of the VS marketplace,
allowing select people to
install and uninstall
extensions that you specify.
Let's check it out. The first step
that you're going to need to do to
create your private gallery is,
create an empty folder.
Ideally, you want to place
this folder somewhere
that's going to be
easily accessible for the people
you intend to share
that gallery with.
I'm going to make mine local,
but feel free to place
your folder either in
a OneDrive or a SharePoint or
anything like that as well.
Let's call mine my private gallery.
The next thing we need to do is
actually populate that folder with
the Vsix files that correspond to
the extensions that you want
displayed inside the gallery.
Luckily I have a few on
standby. Add those in.
Now from here the crux
of the entire gallery is
based on this XML file
called an Atom feed file.
This is very similar to
an RSS feed that you might
see with podcast or websites
and stuff like that that
will keep a record of all of
my Vsix information that needs
to be displayed in that gallery.
Once you share out that file
path or that corresponding
URL with the people who you need
to have access to this gallery,
they can all get that same updated
information as you continue to
iterate on your gallery
or update any of
the extensions within
it and all that jazz.
There are a couple of
ways to create this file.
The first is manually,
which is not the most fun option,
but if you want to do that,
all power to you, or
you can also just have
that XML generated automatically
via a third-party tool.
For instance, Mads Kristensen
has a private gallery creator.
This is an executable that
you can just run within
your folder or if you prefer
the first-party options,
we recently added a new tool
called the Vsix Util tool,
which is short for the Vsix
command line utility tool.
That's what I'm going to demo today.
In order to use the Vsix Util tool,
first is you're going
to have to have
the build tools NuGet
package installed,
which is this one right here.
Then we're going to navigate to
where that NuGet got installed.
Mine by default showed up
under my user profile,
but your mileage may vary.
We are going to go from that package
to the latest version or
whatever you installed,
followed by tools VS-SDK.
You should see the
executable right there.
But we can't just run that
executable file from here.
Instead, we're going to
copy paste this path.
Then in any terminal of your
choice, you can use PowerShell,
I'm using Developer command prompt,
we're going to navigate
to that location.
From here we are going to
write the following command.
Let's do Vsix Util.
Then the keyword today
is createvsixfeed.
This is what's going to
generate that XML file.
Now I need to indicate the source.
Where's that XML getting
it's information from?
In this case, I want
the path for my private
gallery folder that I made.
Then indicate where I want
the XML file to end up.
I'd like to end up
in that same folder.
Then finally, let's name
the XML atomFeed_test.
There we go, it tells me that
the feed has been
created successfully.
It even gives me the path
of the XML which I'm
going to go ahead and copy
right now because we're
going to need it later.
If you're curious,
you can go back to
your folder where
you output the XML.
A bunch of icons have
been generated as well,
but we also have this XML file
that you can open up and take
a look at it if you need to.
As you can see, this
is storing all of
the related data for
each extension that is going to be
included in your private gallery.
This is the critical
bio about this file,
nobody else will be able to
see the private gallery.
But we're not done yet because
we still need to actually
get the gallery to show
up and Visual Studio.
In order to do that, we
need to go into Tools,
Options, then search for Extensions.
You'll notice that, I'll
just scroll up a little bit,
there is an additional extension
galleries block right here.
We're going to add
a gallery like so.
I'm going to call my gallery,
"My First Private Gallery."
From here you can either add
a URL link that corresponds to
that XML that you generated,
or in my case a file path,
and that's what I
just copied earlier.
We're going to apply that.
There it is. This may look like
you're done because
it showed up here,
but that is not true.
In order to test it out and make
sure that it actually works,
we can go into Extensions and
then the Extension Manager.
Just like you'd be able to browse in
the VS marketplace for
extensions that you want,
you can now do the exact same
thing in your own private gallery.
You can download, install,
uninstall extensions here,
but its exclusive, it's
the VIP experience for
a select group of people,
so this is really cool.
What's great about having this
RSS feed style XML file is,
once you, again, choose to
update any of these extensions,
all you'd need to do is run that
same createvsixfeed command
and update your V6s and everybody
will get access to
that same information.
That is how you create
your very own private gallery
in Visual Studio 2022.
The next time you have
an extension that
you don't want the
whole world to see,
be sure to check out making
a private gallery and only
sharing it with a
select group of people.
You can learn more by checking
out the related docs.
Until next time, happy coding.

Debug faster with IntelliTrace in Visual Studio 2022

[MUSIC].
>> Hi, my name is Mark Downie I'm
a Program Manager on
the Visual Studio Production
Diagnostics Team.
Today I'd like to talk to
you about IntelliTrace.
One of the weaknesses of
traditional or live debugging
is that it only understands your
applications current state.
We have very limited
data about past events.
To help you may decide to send
login flow to the output window.
You either have to infer
these past events based on the
applications current state,
or you could recreate these events
by rerunning your
application over again,
but this tends to be
really time consuming.
IntelliTrace is a Visual Studio
Enterprise feature that expands on
the traditional notion of debugging
by recording specific
events and data.
These events might include
module load activity or web
requests or breakpoints.
IntelliTrace then lets
you switch between
traditional or live debugging
and IntelliTrace debugging,
allowing you to see what
recorded information you
might have missed without
forcing a restart.
Let's see this in action.
I have this ASP.NET application.
It is an open source
application and I'm
going to use IntelliTrace
to help me keep
track of very important
events as I get deeper and
deeper into this debugging
and diagnostics session.
I'm going to go ahead and hit
"F5" and start debugging.
That will rebuild my application.
It will also start the
application for me.
It will start running
the application and load
a bunch of symbols so that
I can debug correctly.
Before I start
recreating the scenario,
I want to debug,
I'm going to go ahead and set
some strategic breakpoints
that'll help me with
my session here.
I'm going to go ahead and set
a breakpoint here at line 69.
I'm interested in the
whole action of going to
get comments for each
of the posts here.
I'm going to hit
"Control F12" which will
take me to definition
of this method.
Yeah, I'm really interested in
the data I pass to this method.
I'm interested in seeing
post ID or comments.
Let's take a deeper actually
passed those same values onto get
comments for hit "Control
F12" on line 437.
Again, this is the same
data being passed again.
I'm going to go ahead
and pass over this.
I don't need a breakpoint here.
Control F12 here takes me to
some interesting points here.
I'm interested in
seeing what the data
I get back from this method here.
That's really
interesting on line 1360
and certainly before I
returned this method back,
I'm interested into seeing if
actually even get any data here.
Let's go back to the way we
started the blog post controller
because we'll be making our way
back to the top of the call stack.
I'm certainly very interested
in if I have any blog posts and
taking a quick review there.
I'm going to go ahead and recreate
the scenario I'm debugging.
Hopefully that'll mean I hit
a breakpoint perfect
at my breakpoint.
Now this opportunity, obviously
I can review some data here,
and yeah everything seems to
be working as I would assume,
I can check values and
variables that have
been passed in at this moment.
I can check everything that's
typically what I would
expect at a breakpoint.
Fantastic. Let's keep going
as we hit 'Continue'.
We hit our next breakpoints,
which I strategically put
in another method here and
I can check the values being
passed again heating "Continue".
Again typical of what I'd expect,
I can take the date which is
back in February of 2020.
Perfect I can go here and see
exactly what information I
returned for comments I got
zero there and hit "Continue" again.
Now this is only just five.
I've only hit five breakpoints,
but you can imagine sometimes you
get several layers deep here.
You can decide at this moment
you'll notice right at the top,
what's lit up here are a
couple of additional icons.
Now these are the
IntelliTrace, step back icons,
which essentially say to you,
you have the opportunity
to go back in time.
I'm going to go ahead
and hit the "ALT,
Open Brackets", which is
the step back shortcut.
You'll see now I've changed
slightly Visual Studios,
change the top part.
Now he's describing the I'm
in historical debugging mode.
It's saying that there are
participating windows that
are also historical
debugging for me.
It's also giving me
the opportunity to
return to live debugging
at any moment.
If I look at the bottom here,
I've got autos in
historical debugging.
I've got Watch in
historical debugging,
so I can potentially add things.
They've got locals in
historical debugging,
and my Call Stack is also
historical debugging.
Instead of assuming I'm in my
controller and interaction,
it now sees that the last
time I was in this moment,
I was actually in
internal get comments,
which is the top of the call stack,
which corresponds currently
to the method I'm in.
I can take another step back.
I can hit "ALT Open Square Brackets"
again and take another step back.
I get to see now
the context of the moment
I was at this breakpoint.
Now notice I've still got this value
because obviously that
would have been executed,
forget date for entry on line 1359.
However, after this or these
values are all null because
again, there hasn't executed.
IntelliTrace has taken the snapshot
at this moment in time and
associated it correctly
with the line
I was at when the
snapshot was taken.
I can keep going back to these
moments that are important to me.
Again, going back to get comments,
I can see the values
that were passed in at
the strategic moments that were
important to my debugging session.
Now I no longer have to
remember all the details about
every single moment that led to
the era or the problem
that I'm investigating.
I can use breakpoints not
only as pausing moments,
but as moments of collecting data
that might be helpful to
me later down the line.
I can continue to go back
in time at this moment.
Or I can return to
my live debugging,
which means I'm going to basically
continue with what is
traditional live debugging.
I'm now back to the
yellow highlighted
line saying that this is the
next line to be executed.
What is also really
important is that you can
use the diagnostics tool
Windows to pick any of these
previous breakpoint moments.
If these previous
break and step moments
that allows me to hydrates
on past historical moment.
You can go to the debug
menu item Windows,
and Show Diagnostics Tool.
This opens up the diagnostics tool.
If you look at the events,
you will see a series of
these snapshots that I've taken
at each of these breakpoints.
I can choose to activate any one of
those by simply selecting
and clicking "Activate".
I can go back to a specific
historical moments
in time that I know that's
important to my current debugging.
Today I was able to demonstrate
how IntelliTrace is able to help
Visual Studio Enterprise users
expand on the traditional
notion of debugging.
IntelliTrace step back
can save you time
when you want to see the
previous application state,
but want to forgot that dozens
of restarts necessary to
get your app back into
the desired state. Thanks
for joining today.

Chief Gaming Officer Experience

[MUSIC]
>> I have no expectations
with this all.
I know it's going to
be something unlike
anything I've ever
been through before.
I've got to meet Jen Taylor who's
the voice of Cortana from Halo,
which is a total
fanboy moment for me.
I got to meet Major Nelson
this morning, Larry Hryb.
>> How's everybody
doing on Mixer today?
Well, I got a little
something special
for you. You're going to love this.
>> Again, Xbox Live for life,
Game Pass for life as well.
Had lunch with Xbox's executives
Mike Baugh and Brian Coles.
I got a bunch of stuff
from Microsoft Stores
and all kinds of Xbox swag really.
[MUSIC]
>> Took a tour of the Halo Museum.
They've been amazing,
it's been exciting,
and fantastic, and overwhelming,
all rolled into one.
You stay tuned to the Microsoft
Rewards Team, it's incredible.
Probably one of the best
experience of my life.
[MUSIC]

Chief Gaming Officer Experience (extended)

[MUSIC]
>> Microsoft flew us
out here from Chicago.
Put us up in a hotel.
I had no expectations what this all.
I knew it's going to
be something unlike
anything I've ever
been through before.
This is the biggest thing I've
ever won. This is awesome.
[MUSIC]
Well, I've got to meet
Jen Taylor who's the
voice of Cortana from Halo,
which is a total fanboy
moment for me because
that's Halo is what got me into
gaming in the first place.
>> Cortana, what's the weather?
>> It's clear and beautiful.
>> Okay.
>> I got to meet Major Nelson
this morning, Larry Hryb.
I've watched bunch of the stuff,
history, watched the award
shows, and MNA's done it.
It's really a chip to meet
Major Nelson in person.
>> How is everybody
doing on Mixer today?
Well, we got a little
something special
for you. You're going to love this.
[MUSIC]
>> I get Xbox Live for life,
Game Pass for life as well.
It's a really incredible gift.
So, I got to take a tour
of the Microsoft Archives.
I'm a huge history nerd,
so it's cool to see all of
the stuff that has been
accumulated over time.
[MUSIC]
Saw the original prototype for
the controller for the Xbox.
There's all kinds of things I never
would have expected to
see that they archived.
We had lunch with Xbox executives,
Mike Baugh and Bryan Coles,
that was pretty exciting.
It's super nice to know that
they game just almost
as much as we do.
I got a bunch of stuff
at Microsoft Store.
Then, I walk through there,
bought a couple of controllers.
Get us three new headsets,
and all kinds of Xbox swag, really.
I played Halo as a kid and had
gone onto college student.
Now, to be able to be where
it is made is incredible.
Took a tour of the Halo museum.
[MUSIC]
They have a bunch of
promotional stuff,
bunch of stuff that's
been used in commercials.
Day has been amazing,
it's been exciting and fantastic,
and overwhelming,
all rolled into one.
I'm all about Microsoft,
all about Xbox,
and just been an Xbox member
for 12 years now.
I'm an Xbox fanboy for life.
You stay tuned to
the Microsoft Rewards Team.
Anyone that I got to meet today,
Major Nelson, Jen Taylor,
it's incredible.
Probably one of the best
experience of my life.
[MUSIC]

CHAMP app saves babies lives

[MUSIC]
I think in the back of each of our
minds we were planning a little
funeral, and you just didn't know
where it would go after he was born.
>> We'd hear a song on the radio and
we'd be like,
maybe that's one we'd
like at his funeral.
[MUSIC]
>> Winston was diagnosed with HLHS,
which is hypoplastic
left heart syndrome.
>> One in a 100 to about 125 babies
are born with heart disease every
year, and out of those about
1% are born with half a heart.
Out of all the heart surgery we
do this is the most high risk.
>> They lose about 25% of these
babies in between the two surgeries.
>> The standard of care at the time
was to send these families home with
a weighing scale and a pulse
oximeter and a three-ring binder and
they were asked to record
measurements of their baby
every day.
[MUSIC]
>> So we needed a method that we
could actually send something home
with the parents so that we could
better monitor and be alerted if
there were conditions that we were
concerned about with the patient.
We have a Microsoft Surface
that we load our software on.
We call it CHAMP.
We decided we wanted to use
a modern app with Windows 10 as
the operating system.
>> We would log all of his vitals,
and
that app became this
seamless piece to his care.
>> With the daily reports that
come in from the Azure Cloud
if anything is an outlier that needs
to be notified to us immediately
it'll alert us.
>> One night we're debating
do we call, do we not call?
But we logged it in.
>> When we were looking at his
information, he had a couple days of
not gaining weight, he was
breathing a little bit harder, and
he just wasn't happy on his video.
They could pull it from when he
was doing fine and saying, okay,
a couple weeks ago,
this is what he looked like.
Now he looks like this.
We think it is Is part of his aorta.
[MUSIC]
>> We were scared.
It was real, real fast.
>> They did the procedure
the next day and
then I think he went
home the day after.
>> This technology
literally saved his life.
>> The first time that I heard
a child's life had been saved with
CHAMP, I left the room because I
kind of needed to tear up in private
because it was a dream that
I had for a long, long time.
>> The goal is to get this out to
as many patients as possible, so
that we can help save kids' lives
throughout the world eventually.
>> For everyone behind the scenes,
we're very thankful for it.
It saved his life and
how do you say thank you for that?
[MUSIC]