[MUSIC PLAYING]
RYAN BARTLEY: Good afternoon and welcome to Play
Testing Made Easy on Stadia.
My name is Ryan Bartley, and I'm a product manager on Stadia,
focused on the developer experience.
Today, we're going to cover a few topics related to Stadia
and play testing, namely a set of features we conceptually
think of as Develop Anywhere, Collaborate Everywhere.
These provide really the basis of scalable data
and insight that we'll talk about today.
Next, we'll dive into how these features and others can
be used to automatically and efficiently scale
your development and play testing efforts.
And finally, how partners can utilize a new tool
called Channels to find the fun with any Stadia player
at any stage of development.
First, let's have a quick recap of what
brought us to this point.
One of the most exciting things about Stadia
is the ease with which a player can pick up
devices they own and play hundreds of great games
wherever Stadia is offered.
But we had a ways to go bringing that same level of comfort
and ease to our developers and publishers.
During launch, we heard from partners
that there were a few consistent challenges
they faced when bringing content to the platform.
Really quickly, much of our tooling
was centered around the command line
and required knowledge of Linux to do simple tasks.
Next, our infrastructure and the development
paradigms it supported were new and somewhat
difficult to utilize to its full potential.
And then finally, those same configurations
that made it so easy to open up your phone or a computer
and start playing games on Stadia
required a significant amount of configuration
during the development phase, which made iteration, testing,
and publishing difficult.
At the same time, we also started
seeing some really positive signals from several teams,
both big and small, that our Distributed Cloud
Infrastructure became a huge asset to their team,
especially at a time when development from home
was becoming increasingly common.
Ubisoft and Bungie in particular noted how much
this freedom to test and iterate meant to their own operations.
Let's take a quick look at a concept
called packages that really unlocked
a lot of the distributed power our partners
were able to utilize at this time
to build a better understanding of how this provides
the basis for the improvements we'll
discuss in the next section.
Packages are overall a pretty simple concept.
Briefly, it's a blob of the full set of art, assets,
and binary your game produces during a build and cook
session.
But the real power comes from the fact
that the content is securely distributed automatically
throughout your team's cloud instances,
meaning that once the package is processed,
its content is immediately available for your team
to begin playing.
There's no downloads or transfers needed.
This unlocks a ton of possibilities
that we'll talk about soon, as it removes
so much of the time spent updating or downloading
new content.
So we knew we had something special to offer.
And by focusing on the simplicity of the player
experience, utilizing our Distributed Cloud
Infrastructure, and leaning into what already made development
on Stadia so special, we could make a lot of improvements
across a wide spectrum of user journeys.
To detail those improvements, first, we
knew we had to unify the development and iteration
flows around a central set of tools, allowing users
to focus on what they needed to do,
rather than which tool to use.
Next, we sought to reduce or even remove
many of the configuration barriers
that were currently present, further reducing
the need of specialists.
As a part of this as well, we automated
the collection and presentation of the most important data
users required to do their job, further eliminating the need
to know Linux or low level tooling.
And finally, we knew the ability to immediately collaborate
with everyone on the team made packages really special.
So we ensured that wherever possible
we were increasing our partners' ability
to share and collaborate.
These design fundamentals led to a concept
of development and play testing we call Develop Anywhere,
Collaborate Everywhere.
This concept ties together a set of features
into a unified flow, which enables
users to jump right in and easily iterate on content,
while also making the data produced by that content widely
shareable throughout the team.
Briefly, Launch Anywhere allows users
to launch their game to any Stadia client
with a click of a button.
So even if you're on a PC, say, and need
to test what it's like to play the game on iOS,
you can do that.
Test Hub then offers an endpoint agnostic set
of tools and controls for your live game,
as well as providing a unified view
into both live and historic game runs, a feature that
makes real time statistics, logs,
and artifacts easily available to your entire team
to help increase the overall context of issues
you might encounter while developing and testing.
And then finally, Channels opens up the possibility
to amplify your content to a secure, moderated list
of players anywhere Stadia is available.
Now, let's briefly step through each
of these components in a little bit more detail
to get a better idea how they all fit together into helping
your team scale their efforts.
Launch Anywhere allows you to quickly, easily test your game
on any Stadia player endpoint.
With a single selection, users can launch their game directly
from the partner portal, CLI, or Visual Studio, whichever
tool they use most, to their player endpoint of choice.
Reducing this friction enables your team
to have a better understanding of the full player experience.
It's also particularly useful during work from home,
since testers or developers can simply
log into their own Chromecast or Android device
and begin securely playing last night's build immediately.
Now, once your game is launched, Test Hub
comes to life, creating a unified view where
you can control or monitor all your most important game run
details.
When the game is live, you'll receive real time data directly
from the instance, including several performance
statistics and stream logs.
When you finish playing your game,
Test Hub switches to the Game Runs view,
presenting you with all of your captured data, logs,
and analysis.
This view organizes all your most important artifacts
like logs and captures, and makes all of this data
easily and securely shareable across your team.
This set of artifacts is also easily expandable.
If the information you need isn't captured,
simply upload it, and it's available to everyone
who might need it.
This allows your teammates to jump
into an issue with all the context
they might need to quickly solve it.
Building out Test Hub to represent
both live and historical game run
data in this centralized view makes
it easier for any user to quickly find
the information or control they might need to do their job.
Now finally, Channels expands on your ability
to securely distribute and share access
to your games and new content within a process that
is entirely controlled by you.
This allows you to expand your alpha and beta
tests far beyond your normal friends and family,
regardless of what phase of development you're in.
This allows you to also even expand
the audience to internal QA and press
before you release your game.
All right, now that we've talked about all these features,
let's see them in action and how they can scale your play
testing efforts.
First, we'll start at the command line.
In most cases, teams are producing new content daily,
either as a part of design, art, or updates to game
functionality and binary.
As we just spoke, packages really
allow your team the ability to scale internal processes
significantly by amortizing the time it takes for your team
to access that daily content.
Now to do this efficiently, Stadia
allows you to create what we call a test account
and give it the Build role inside your project.
This will allow you to script and automate
the upload process alongside any of your build and cook jobs.
Setting this automation up is an integral first step
in unlocking the power of Develop Anywhere,
Collaborate Everywhere, because it enables a consistent flow
of content and, as you'll see, empowers
teams to scale dramatically.
Once a package is processed, it's
now available to your entire team
wherever they're developing.
This access really opens up some exciting possibilities
for your testing team in particular.
So let's focus in on them for a second.
Now in this case, testers could be QA,
or they could also be producers, or release managers,
or even executives, anyone who just really needs access
to the content to get a better idea of where things are at.
And because of the unification around cloud native features
like Launch Anywhere and Test Hub,
we've made it so that testers in this case
don't even need to download an SDK to play and test
their daily builds.
The tester could simply access the partner portal
from their phone using their developer account,
execute a launch, and begin playing the build instantly
using either their Chromecast or even the same phone they
executed the launch from.
But what about the data from those tests?
Well, like we said earlier, Game Runs captures much of the data
your game produces in real time and makes that data
available to your whole team in the same way
your package is available.
This allows you the ability to monitor and control
the game while it's live and share and collaborate
on that data after it's over, immediately.
Let's say you hit a problem in your game,
or you just want to try out some new functionality.
After you've finished, you can quickly
share the data you've created with your team,
giving them the context they need to jump in and understand
things quickly.
This same type of sharing works for certification as well.
Now every test result from certification
comes with an accompanying set of game runs and artifacts
that were produced during the test.
We believe this will help teams find and fix issues
more efficiently.
And the best thing is as we continue to add new artifacts
and functionality like crash dumps and tooling captures,
they'll all be available to your team immediately.
You won't need to learn new tools
or teach new user journeys.
But what about developers and designers,
users that really need to change parts of the package
or iterate with deeper control of the game?
Packages also support their workflows as well.
Stadia has created several ways to empower asset iteration,
while also utilizing the scale distribution
and access of the package.
These users can simply mount the particular package
to their instance and then use overlay functionality
to update specific parts of the package,
such as binary, shaders, or art.
And there are a few different ways they can do this.
Users could manually copy the full assets, like a new binary
or texture, directly to the instance.
They can also copy a diff of the original asset
if only certain parts of the asset have changed.
And then finally, they can mark a particular asset
as changing, which will then cause
a partial stream of the parts of the asset that
are used by the instance.
Each type of iteration empowers users
to choose what's best for them in a particular circumstance.
This ability to only upload diffs
extends even to packages as well.
And utilizing this in your automated or manual uploads
will increase your package iteration efficiency even more,
decreasing overall upload times and making
your packages available to your team even faster.
Another growing piece of the play testing puzzle
is automation.
And Stadia helps make this easier as well.
The test account that's used to upload the
build can also be utilized to launch the package when it's
finished processing by using a headless client
for the execution of the actual game.
The automation can then gather up
any and all data produced on the instance
to make available later.
To do this, the build account will create another test
account using the CLI and then launch the game with that test
account, along with any configurations
necessary to kick off the automation.
Since the client is also headless, all of this
can take place on the command line along with all of your
build and upload automation.
You could also use this to get a quick lights-on test
of your game to make sure there are no problems
with the build before your team gets in to test in the morning.
Once the game is launched, you can
monitor the game using your regular CLI automation
tools like SSH or SEP.
And soon you'll be able to use the CLI to grab the latest
historical run to help others jump into all the game run
data available.
All of the things that I've just talked about
can scale along with your team's needs.
Getting ready for a release?
Need more help on a particular issue you found?
Or maybe you want to move more of your team
to utilize play testing on Stadia.
All you have to do is reach out to our support team,
and we can give you the resources
you need to be successful.
This is a great segue to another very exciting feature that
can help securely expand your play testing efforts
beyond your team, Channels.
To be a bit more specific, Channels
utilizes the same safe and immediate
access model that makes packages so useful to your team,
but widens the scope of available user bases
beyond your team to anyone or anywhere Stadia is available.
All that player needs is a free Stadia account,
and you can make your game available to them
with just a few clicks.
Let's take a look at another key feature which
makes Channels so exciting.
Normal testing with alpha and beta users
could cause players to download several enormous builds
to test different functionality after the game is
made available.
But using both the same diffing mechanism
that's available to your team with packages and the fact
that Stadia doesn't require downloads
or updates, any changes you make are
immediately available to your moderated audience.
This should allow your team to make updates when necessary,
rather than collecting things up over time.
We believe that with the features and processes
we've shared thus far, your team should
be able to scale their development
and play testing efforts.
But we're not finished.
There are several exciting ways we
plan to continue growing this functionality
over the coming months and quarters.
For instance, saving project level configurations
and automatically reserving instances
should help reduce the overhead even more
for your testing team, as well as
the ability to search game runs and access them from the CLI.
And finally, we want to add several new artifacts,
such as crash dumps and tool captures,
to the arsenal of game runs data.
By removing the previous barriers around how,
where, and when you can test your content,
the Develop Anywhere, Collaborate Everywhere
set of features will empower your team's
overall efficiency and ability to scale, making it easier
to develop your game.
Please apply at Stadia.dev to learn more
and to begin using these features today.
Thank you so much for your time.
[MUSIC PLAYING]