>> Hey, friends. It's the
Visual Studio 2022 launch. We're still here. We're working remotely. Thousands of you have downloaded the preview of Visual Studio 2022, but today, we're going to launch it for the millions
of developers out there that are excited about making great stuff with Visual Studio. We've got just demos,
no PowerPoints,. We'll also talk to the
developers that made Visual Studio 2022 a reality. We're going to have a
live chat going on, so be sure to ask your questions, the entire teams will be
available to answer them. Now, before we show you the
awesomeness of Visual Studio 2022, let's talk to our
first guest today who leads the product team for
the Developer Division. We're going to hear from her
how Visual Studio 2022 came to fruition and what the vision is for the future of Visual
Studio. Hey, Amanda. >> Thanks, Scott. >> How is it going? >> I'm glad to be here. >> Yeah. So you're the CVP for the Developer Division in
Visual Studio, and you've seen lots of releases for
Visual Studio over the course of your time here. There's thousands of developers
that are watching and learning today about what Visual
Studio 2022 is all about. What's the vision and why
should we care about 2022? >> Well, every release of
Visual Studio is a moment. It's so exciting to
actually make sure that every developer's
day is more joyful. We really try to make sure that every version of Visual
Studio is more performant, it's more reliable, and this one is. But this one, it really is a very special release
of Visual Studio. It's the first version that's
been re-architected to be 64-bit natively, and so that
means that for a lot of developers who have
large-scale solutions, they're going to experience
more performance, fewer out of memory exceptions, things like that, better
reliability overall. The other thing is we always try
to improve that edit debug cycle. A lot of the improvements that
we've made with IntelliCode, bringing AI to actually help you
write the right line of code, that makes every character you write more productive and more on point. Then the last thing is
we've really improved the cycle to do debugging with Hot Reload so that you don't need to stop to be able to see the change in the application
that you're writing. >> So that the
developers inner loop, make a change, see the change,
make the change see the change. >> Right. Exactly. Don't you want to see this as soon
as you thought of it? >> That's so cool. We could go on about this, and we could
do talking points, and we can do marketing. But what we're going
to do instead is we're going to show
demos, and you've brought some folks from the team
to show me those cool demos. >> We have some amazing demos and
some awesome people that have been on the team working
on these features firsthand that are going
to be talking about them. >> Fantastic. So who's up first? >> I think we have Kanika. >> Kanika works on the Visual
Studio Team on performance. Welcome. You're going to talk to us today about Visual
Studio and what it brings for developers
performance and scalability. >> You bet and I got
a demo we can roll. >> All right, let's roll the clip. >> We're looking at
a large solution. When you open those solutions, you'll go get coffee so that
Visual Studio can settle down. What we're trying to make
that a thing of the past. This is a 176 Project Solution
Orchard Core on .NET 6. You can see how quickly
the solution loads. Everything's interactive. All your navigational
elements are right there. Look at Solution Explorer, you can interact with almost
all elements of that. The other navigational
elements, Search is also there. You can search for your files, look at how quickly the results
are there, click through it. You can scroll through the file. Everything's ready. You can interact with it even
as colorization comes through. >> This is all real time. We recorded this
together on my computer. >> Exactly. >> This is not been sped up. >> No, no. This is
exactly real time. We made the change
and we are going to now build the solution to make
sure we didn't break anything, and we made a lot of changes
to increment the built. First off, it doesn't
assume just after you've open Solution that
everything's out of date, they only builds things
that it's supposed to. Secondly, faster predate
checks, four-time faster, which means all your builds regardless of whether
they've been triggered for are faster. So look at that. Only seven solutions
that needed to be built. We'll take a quick
look at Test Explorer. We broke some test, Scott. We're going to go ahead and
make some changes to fix that. >> It looks like we'll
revert that because that was probably getting ahead of ourselves. >> Yes, it was. So that and then we're going to go ahead
run those tests again. >> Look how fast the
Solution Explorer just got you right
where you wanted to go. >> Exactly. That search has
been optimized and improved. The other thing is look at
the unit tests being run. It's hot reloading them so it's
not building everything again. >> Wow, so you didn't do
a rebuild right there. It's hot reloaded the test and
ran it, and now, we fix them. >> Now that our fix is done, we can just close the Solution
and on our way we go. >> That's cool, responsive
at every moment. >> Exactly. Faster and responsive. >> Visual Studio 64-bit, who
wouldn't thank it? Fantastic. Actually, let's bring Anson and
he's a partner architect that works on Visual Studio and
was instrumental in moving it to 64-bit. Hey, Anson. >> Hey, Scott. >> Thanks for hanging out. 64-bit, why didn't you do it before? >> Good. Soft, tough
question to start and you asked it very emphatically, and I think that's the same that users are asking why
now and why not before. The reality is that
there were several considerations that we've had over the course of basically 64-bit. We've thought about
it for a long time, and one of them was around usage, which is how many folks had 64-bit machines they were
installing Visual Studio. In particular, how
many people were still installing those on 32-bit OSs? The thing that was interesting
to us is that even though 64-bit hardware has been
around for a really long time, and we found that a number
of people were still installing Visual
Studio on 32-bit VM. That surprises and that
was a reason that we were maybe we shouldn't pull
that trigger right away. >> I'm thinking about this as a
person who lives in the ecosystem, I've made extensions of my own. If you release two, then
I'm going to release two. But then if you go to 64-bit, are you going to leave me behind? That's concerning as well. >> Yeah, that's an awesome point, and that really leads us in quite nicely to a
second consideration, which was that ecosystem
and extensibility area. Now, one of the things
that was good is we've made some changes in the past couple of releases
that have required extension authors to
react and update to the changes that we made
for both performance and reliability reasons,
and they have done it. The extension authors
have really done just an absolutely
amazing job during that adaptation so it gives a lot of confidence that moving forward. It would do the same
thing for your 64-bit, and we may have seen that with 2022. >> We've also got
things like .NET and .NET Core that have enabled
us to do things as any CPU, so some people could
move their 32-bit things forward and not have to worry
about anything, just worked. >> Both on the C++, I'd really
can write portable code, but on the .NET side, we did see an increase
in the percentage of extensions within the marketplace
that were doing exactly that and making it so that
transitioning was actually fairly straightforward
for those folks. >> It seems like
this was the moment, it was a convergence of a number
of things that happened that made this possible and then
up-leveling from that, what can we do with
all this new power and all this new memory address space. >> Scott, we have the Architect
of Visual Studio here, let's geek out for a second. >> Okay, my bad. What are some things
technically that you had to do to make it work in
32-bit that now you can think about differently
in the context of 64-bit? >> It's a great question
and it allows us to actually do two major
things that I'll mention one which was that we
used to induce TCs during times when we knew we had an opportunity,
collect a bunch of memory. We don't have to do that anymore. >> You're forcing
garbage collection. >> We used to force
garbage collection during startup, and now,
we don't have to do it. Secondly, we actually used to do a thing called
partial engine where we only predated a small section of code that we knew
users would hit, and now, we can actually
engine quite a bit more and increase performance. >> You're doing native image
generation engine and just in time, compilation more now because you've got more room
to move with 64-bit. >> That's exactly right. >> Performance is really a
focus of Visual Studio 2022. Performance at the low level and
then also at the user level, like what do I get to do
it, my fingers do more now. >> Yeah, for sure. You
definitely want to go from your idea to the code
as quickly as possible. So how can we make every line
of code faster to write? >> Actually, we've got an AI
power demo that we brought, a clip on IntelliCode. >> That's right. You
want to take a look? >> Let's take a look at that. >> Here we are in an
ASP.NET application. But what matters is the code that
you can write and how quickly you can go from that idea to
writing the code in the editor. Everybody is familiar with, you write a little
bit of code and then you see Intellisense come up. But in this case, what's going to happen is
you're not only going to see all the ways that
it can complete, that's just the alphabetical list. It doesn't really give you guidance as to what
you should be writing. What you're going to see here
is that as you write the code, it's actually going to
make a suggestion for the entire line that you
might want to complete. That's basically taking, in that case, it looks
like what 10 characters, basically eliminating 10 characters
that you might need to write. >> Wow, it's multiplying my power. >> Well, I think that's
what's so key about this, and what's so awesome is
writing code actually becomes this exercise of
hitting tab because all I needed to do to accept that whole
line of code is to hit Tab, Tab to get the entire line, and
so it'll just complete for you. >> How does it know? >> It's actually based on
machine learning models. So what we've done is we've
taken a look at a lot of public code and
inferred based on that, a machine learning model
that we can use to have predictive guidance for you as
you're writing the line of code, what is the most likely next line
of code you're going to write? It's basically looking at
a combination of all of the code that we've trained
this model on top of, combined with the code that you've already written in
the application thus far. >> It's not your
machine learning model, it's yours plus mine, that's specific to my code. >> What it really is doing
is it's basically created a machine learning
model that is generic, that is based on what
everybody has written code about in ASP.NET as an example. But then it's taking that
and combining it with the code that I've written
thus far in this program. One of the things that's
so important about this, is it's not just how fast
can you write the line of code that you can hit tabs and you don't need to
do all the typey typey. It can actually give
you an indication of what is the right
line of code to write. For example, we have this
add Password Results, and in this case, it's an
async call, you can say await. But also it can tell you what are the right parameters to
pass into the method. >> That's amazing. This
is really going to make my life editing
code a lot easier. Hopefully, I'll be able to see
the results very quickly too. >> Yeah, I think you're going
to become a Tenex developer. >> I don't know about that. I'd be happy to be a one Tenex
developer at this point. >> Now, what you can see here is
that it actually can say Var, add password results and it can give you the completion of the entire method, including the arguments that you might want to pass
in to that line of code. It's super useful for learning new APIs because it
also means that it can actually give you
guidance as to what's the invocation order for the
APIs that you may need to call. >> It seems to be getting
smarter and smarter. >> Well, I certainly think that that's what everybody
will experience. >> That's a really
amazing innovation. This AI runs locally? >> Yeah, in fact, even if you
were coding on an airplane with spotty Wi-Fi, you'll still get all of this guidance
as you're writing code. >> IntelliCode in
airplane mode. Very cool. But actually, we've got another
guest to come in and show us what happens after you've edited your
code. Let's bring in Erika. [MUSIC] Erika is a Program
Manager on the C++ team. >> Hey, Scott. >> Thanks for hanging out >> Thanks for having me. >> We have explored editing
and we've seen IntelliCode, but the next big area in Visual
Studio 2022 is Hot Reload, and we going to Hot
Reload all the things. >> All the things. >> Now, I'm a.NET person, I'm familiar with.NET,
so I get how that works. But honestly, I haven't
done C++ in many years, and I know that you
are a huge C++ fan. >> Yes. >> Your team is doing
some amazing stuff that I didn't think was possible. >> Yeah, so Hot Reload
applies to C++, I actually have a demo with
me that we can walk through. >> All right, let's check it out. >> All right. This is Bitfighter, which is an open-source
cross-platform CMake project that's running locally on Windows. In this game, that blue
little triangle is a ship, and a ship has a shield, which right now is expressed
with that red circle. If I wanted to make a design
change to that shield, I could change its
appearance without setting a breakpoint or restarting
the game with Hot Reload. Here I'm over in Visual Studio, game is still running, and I'm changing that shield
from a circle to a star. I'm changing the color
from red to blue. Whenever I'm done making my edits, I just need to press the Hot Reload
button to dynamically inject those changes into the game and
see them realized in real time. It's exactly like you
were saying earlier; edit, see the change. Edit, see the change. I made this change on the fly, I didn't need to pause execution, which can save you a ton
of time between edits, especially if you need your app in a very specific state in
order to verify a change. >> Erika, I'm trying to get my
head around how that works. >> It's pretty cool. >> You guys, this is amazing. This is something that previously
was really only available to Web client developers
creating Web apps, and now this is available for
native developers writing C++. >> Yeah, and not just
game developers, all native applications
can leverage this. >> That is amazing. Hot
Reload all the things. >> All the things. >> I'm going to have
to learn C++ again. But I do really like my C#, do I get Hot Reload also? >> You're in luck, you
also get a Hot Reload. Olia has an awesome demo for Hot Reload for .NET developers
that we can roll now. >> All right, let's hear from Olia. >> Thanks, Scott. I'm Olia. I work on .NET desktop, and let's dive into the demo. Let me open Visual
Studio and show you new features in WPF and WinForms. I'm going to build an
application to track air quality in different cities. As usually, I will
have some shared code, some business logic, and I'll have different clients. In my case, I equally
love WinForms and WPF, so I'm going to build
a client for each. Let's start with WPF. I have some basic UI in place
and I'm going to generate the cities and
corresponding air quality with the following data template. Here I'm going to use data binding, and the problem is I cannot see how my data will look like in the
app here in the designer. For that, we have a new feature
called Design-Time Data. Design Time Data allows
you to mock any property, and set the values
that would be shown specifically in the designer. By adding D column to
any XAML property, you can get values in your
designer, like I just did. Perfect. I have my data, I see how it will look like, I want to make minor tweaks. For example, I want to
change the font of that. Here's another new feature we
have called Quick Actions. By extending light bulb,
I can change fonts, colors, anything I want
with just one click. Perfect. I'm happy with how my application looks like,
and I'm going to run it. Let's assume I developed WinForms
application behind the scene, and I have my both WinForms
and WPF applications. But something is wrong with my WPF. Let me debug my app while it's running using the feature
called Hot Reload. For that, I'm going to use another new feature
called XAML Live Preview. XAML Live Preview allows me to
see my running application inside Visual Studio, so I
don't need to switch back and forth between Visual
Studio and my running app. Not only that, but it also has great tooling for pixel-perfect UI. I can add rulers, I can measure distances, I can select controls, and all that fun stuff. Let me look at my item control, and here I see that I forgot
to specify item source. I'm going to quickly fix it, and there you go. I see that my application is fixed while it was
running, right away. Great. I think I'm happy with how everything looks like
except one part. I noticed that cities
here are all Los Angeles. That means I have an
issue in my data logic. Let me go ahead and fix that, and my WinForms and WPF
applications are still running. Yes, I forgot some
test code right here, so I'm going to do that. I'm going to save it. Let me show you one
new feature we have. In Hot Reload menu, we have Hot Reload on Save. Now, I just Save my changes. I'm going to go back
to my applications, hit "Refresh", and I
have real cities here. By the way, .NET Hot Reload
works even without the debugger. My WinForms app was running without the debugger and Hot
Reload still worked. That's it for me. Thank you so much. >> While I was actually joking when I said Hot Reload all the things, but the Visual Studio
2022 team is not joking. >> It is the hottest release
of Visual Studio ever. >> Everything is Hot
Reload, C++, .NET. We're going to hear from
partner architect David Fowler, who's going to show us
Hot Reload in ASP.NET. [MUSIC] >> David, you got demos? >> Yeah. Like I said, we're doing a Hot
Reload for Blazor WASM. >> Blazor WASM, WebAssembly. >> Let's see it. >> Right in the browser, we're
hot reloading everything. The app is running, it's making pizzas, think of it as a pizza shop. We're going to show off
a Hot Reload demo which will make the inner-loop much faster with a single file save, so you don't have to rebuild the entire
application to see those changes. Here's the application,
it has a bug somewhere. There's no image with the pizza, there's supposed to
be a preview there. We're going to fix the bug, it's
probably somewhere in the code. There it is, there's
a bbackground image, it should be background image. We're going to do a very
simple fix to fix that typo. Keep your eye on the
Save icon right here. We won't have to rebuild. Single Control S will push the changes from your IDE
into the application in real time. That's insane, right? In the olden days, you had
to build the whole thing, wait for it to recompile,
and make it work. Now, we can actually
do it in real time, in the IDE, and have it put to your application in the first place. Second bug here, I can even make
a kid's pizza with just cheese. No one actually made the pizza
support more the one topping. There's the issue it has,
the max is one topping. Let's make it six. From 1-6, Control S again, just saving. Boom, it went from a
textbox to a dropdown. Now, I can add more toppings
to the actual pizza. Fresh tomatoes, gross. >> I didn't want to ask
you about pineapple. >> Oh, only in Hawaii. Six toppings, and
then we have to add the totals column to our site. The entire time, I haven't
built anything ever. Just to hit Control S after
adding pieces of code. It's huge. I did that. Now, it shows up in the actual UI. Total price of the pizza. Now, we're going to show
you Hot CSS Reload. We had Hot Reload from Razor, and now for CSS. What's pretty cool here is
that you actually don't have to hit "Control S"
to make this show up. As you type, since that is
correct, it will work just fine. I can type in real
time, hit semicolon, and have the changes reflected
in the application in real time. You see, I haven't saved this yet, and the changes will be actually reflected in the actual application. >> Hang on, you didn't
just Hot Reload HTML? You made us super-hot CSS, you didn't even push "Control S". >> Spicy. >> Very spicy. You also did C#. >> C#. That's new. >> C# anywhere, any kind of C#? >> Anything. >> Not just Razor? >> None is Razor. It could be Web, Client, Mobile, anything. >> Wow. >> Yeah. >> Okay. It's happening. >> That's the big
change. Yeah, it's huge. >> It is huge. it's Hot Reload. >> We have been chasing this
for about 10 years now. >> Really? >> We've got it finally. >> This is a huge release. >> It's huge. >> Oh, my goodness, it's
amazing. We've seen how to edit our applications. We've seen how they get hot reloaded
all the time, all the things. We can then put them
into production, and then we need to find
out what's happening. We need to profile them, we need to see all that great
tooling inside of Azure. We've got Mark to show
us that right now. >> Thanks, Scott. Visual Studio is way more than just a code editor. It's a full suite of
tools that allow you to diagnose and analyze how
your code is performing. After creating and deploying your carefully crafted
code at some point, it gets put through the fire
of customer expectation. When it does, Visual
Studio can help you refine your app to scale with the
most complex of situations. Take, for example,
this piece of code. This is an ASP.NET application designed to process thousands
of data records into files. The process is split into
distinct units of work which are represented by these
three .NET tasks. The final step here is to
return success when I'm done. Now, my DevOps team tells me this operation is consuming
way too much CPU. But we know that this is
strange because the bulk of the code is concerned
with file operations. The DevOps team used
Azure Monitor to capture a trace during the CPU spike
and shared it with me. Now, rather than using my intuition, I can open the trace
in Visual Studio and go directly from
problem to code. In the trace, I immediately see
Top Functions and Hot Path. The hot path indicated
by the flame icon, tells me exactly which code paths
are consuming the most CPU. This is a great place to focus
on for any CPU-bound problems. Alternatively, I can use
our new Flame Graph view as this demonstrates graphically
which areas I need to focus on. Regardless of which view you prefer, the true magic that Visual
Studio Lux is that it helps you go from problem to code. I'm going to double-click
on my frame in the Hot Path and hit "Highlights" for me the
code of greatest concern. This is in fact a badly
designed regular expression. It had nothing to do with processing
thousands of data records and the profiling tools in Visual Studio helped me to prove
it back to you in the studio. >> If ever there was
a demo that really reinforced that Visual
Studio isn't just an editor. It's an integrated
development environment. You're at this powerful cockpit of all the things from production,
editing, Hot Reload, all that stuff. Is everything that we've
seen available for everyone or just in the big money
paid versions of Visual Studio? >> No, what we want to make sure is that every developer
that's coding in C or C++ can actually develop any application super
productively for any platform. >> Any platform, not just Windows? >> Any platform, yes,
not just Windows. Linux, I think this
is one of the big things is that a Visual
Studio has actually become an incredible environment for
developing apps for Linux. >> That's fantastic.
Actually, I've been spending a lot of time with WSL, the Window Subsystem for Linux, which is a huge part of Windows 11. Are you saying that Visual Studio
knows about WSL and Linux? >> Yeah, for sure,
and Erika actually has an awesome demo
that she can show you? >> Definitely. >> All right, let's check it out. >> Let's roll it. We're
starting with a CMake project, open and Visual Studio. CMake is an open-source
cross-platform build system generator that's supported natively
by Visual Studio, and it is our recommendation for
C++ cross-platform development. Now, because CMake
is cross-platform, I can build and debug this
project on my local machine, on SSH connections, on WSL distros, all from the same instance
of Visual Studio. I'm also using Visual Studio's
new CMake presets integration. This file, CMakepresets.json
is supported directly by CMake and can be used to drive CMake generation and build both
with and without our tools. That means your team can
use it from Visual Studio, from VS Code, from the
CMake GUI in a CI pipeline, or from the command line on
Windows, Linux, and Mac, which makes it a great
option for team to like to support a
diverse set of tools. I've already configured
this project so I can start debugging on WSL by pressing F5 using Visual Studio's
native support for WSL2, which is brand new in
Visual Studio 2022. What we're looking
at is pretty cool. This is a Linux app running
natively on Windows with WSLg. The g stands for
graphics and Windows 11, and you can notice the
Linux style controls as well as the Linux tiling up in the corner
which shows we are in fact launching this
from a Linux instance. In Visual Studio, I
have the full suite of debugging features
available backed by GDP. Which means I have a rich visual
experience for things like inspecting variables or using
the parallel stacks Window, which is open to the right. That's an example of the
graphical expression that you just can't really get when you're debugging with GDP from the command line, and it's
all running locally on WSL. >> I'm watching David try to
like emotionally deal with that. >> Picking up my brain. >> Are you okay? >> I don't think well. >> Who's your teammate? >> Holy crap, no. >> You've never seen that before? >> No. >> Isn't that good? It's happening. You can build and debug Linux applications with
Visual Studio 2022. You need to sit back
and just lie down because it's happening. Amanda, the year of the Linux desktop
is happening on Windows. >> Well, I think
this is really about not just Visual Studio
but also Windows becoming a really
awesome developer box for developing apps for Linux. >> It's amazing and not only developing them but
also testing them, doing some amazing tests. I think we have a demo
from Kendra about cross-operating system testing
on Windows with Visual Studio. >> Hey, everyone. Let's
check out what's new in Visual Studio 2022 to test your app. This feature is Bring
Your Own Compute. I'll go ahead and build a
Docker container right now and with the Visual
Studio PowerShell, and while that's building, let's take a look at my tests. I have two tests.
They're super simple. I have a Linux test
and a Windows test, and I'm using the skippable
fact attribute in x unit. I will skip my Linux test if my operating system is
Windows and vice versa. I'll only run by Windows test on Windows and skip
it if I'm on Linux. Now that the container is
built in the background, let's take a look at
our Test Explorer. Right now, you can see this is the remote test
environment drop down, and right now, it's set to my
local Windows environment, and my Linux test is skipped
and my Windows test is passing. I'll go ahead and select
the container that I just built and it will actually rediscover
my test in the background. This drop down is defined by
a testenvironment.json file where you can tell them things like what Docker image
you want to connect to or which WSL distribution you need and anything you need for your
SSH connections as well. Back in my Test Explorer, I've rediscovered those tests, and now, when I run them, it'll be on that Linux container. Now, my Linux test is passing
and my Windows test is skipped, so you can easily debug these. There's lots more you can do. This is just a little
sample of how Visual Studio can bring cross-platform
development into your inner loop, and that's all I have for
today. Back to you all. >> Amazing stuff from Kendra, the ability to be able to test my .NET applications
cross-platform without ever leaving the comfort of
my IDE Visual Studio 2022. >> Yes, so important.
You can write code, you can debug your code, and you can also write
tests in the ID. >> Yeah, but can I check it
in and put it in the Cloud? That's the real question. >> I don't know, Scott. Can you? >> Maybe I can do a demo.
Let me show you this. I've actually got something
for you. Check this out. Here we are in Visual Studio again, and I'm actually going to
right-click and say Publish. It's going to pop up some different options that I've got and one of them is Azure App Service in Linux, and I'm going to pull down
my resource group and we'll see the different App Service instances that I have
available to me. I could make a new one
or I could pick one that's already been
created here, and then I can publish it with the
pub XML file or check this out CI/CD using GitHub Actions. It actually knows
that I'm logged into GitHub and knows what kind
of application this is, so it's going to pick the right
template and it will build my CI/CD pipeline for
me. Check this out. Look at that. It says
GitHub Actions workflow. It brought my published
profile secret out. It knows the context of the Cloud and it's going
to trigger on the push. It's pulled my secret out, put that into GitHub actions, and then all I have to do at this
point for the workflow to run is to go and commit and push
this to the remote repository. I'm going to say Open Git Changes
Window and I'll make my commit, and when they push it, it's
going to fire that trigger, that push trigger on GitHub Actions. Put in a message for
my initial commit, and I'll go ahead
and say Commit all, and then we'll see one outgoing
and we'll go and initiate that push that happened in the
Git changes toolbox there. Now, look, the workflow is
running, so at this point, we've pushed to the master and then that run is
happening in GitHub. We can then switch over
to GitHub and we'll see that CI/CD pipeline
that was created for me happening automatically
go build and deploy. We're 16 seconds in setup .NET core, we're going to run the tests,
then we're going to do the publish, and then we will
deploy to the Azure web app. All of this was created for me. I didn't have to edit
this pipeline at all. Once that post-run is done, my application will start
to spin up inside of Azure. It takes just a second
for it to do that because we're doing a cold start, and there you go, my
app is live right there in App Service on Linux. >> Awesome. >> Pretty cool. A kind of
full circle right there. We've seen all the hot reloading, all the great editing,
all the IntelliCode. We've committed our code
that's been fully tested, put it into CI/CD pipeline
in GitHub Actions, and then publish it to the
Cloud. How fun is that? >> That's pretty cool. >> Is your brain okay from
the Hot Reload demo earlier? >> Yeah. I'm okay now. >> Because I know you
haven't adhered with that. >> Right-click publish GitHub. >> So we've seen some
really amazing stuff from all of our friends and we have to really appreciate
the work that was done by all of our friends
who aren't here today. The organization is huge. Many, many engineers
worked on this project. >> For sure. We're just
really proud to be able to work on this for developers. >> To be able to do
it in the middle of the pandemic is pretty amazing. A lot of this work
was done remotely. >> Yeah, it's been incredible to collaborate across the team
to work on this release, and it's awesome to
see you all here, and it's funny to notice Anson's socks. >> What's going on with your socks,
Anson? What's the story there? >> Yeah, no. These are
Visual Studio socks. Obviously, they are from
a slightly older version. I'm not saying that there
maybe somebody that could flight a new set of swag for this, and if there were such a
person, that'd be great. >> I don't know who has that power. >> Looking great. I think
there is a new logo, so we definitely might need
to update Anson's socks. >> You heard it here
first. Visual Studio 2022 Sock Swag coming at you in 64-bit. What a great celebration and what a wonderful time to spend, and actually, we do have a secret code that we have to
enable it to go and turn on the next step and finally
release Visual Studio 2022. We're going to put this down
and we're going to go to our special control
panel that I'm going to pass to you to launch Visual Studio. >> Thank you. >> Enter the secret code. >> I'm not sure if I remember this. >> Up, up, down, down, left, right, left, right. >> Ready? [MUSIC]
