►
Description
Keynote: Opening Remarks - James Ward, Developer Advocate, Google
A
Hi,
I'm
james
ward
from
google.
Recently
we
announced
grpc
kotlin,
which
is
a
way
to
generate
idiomatic
kotlin
around
the
protobuf
and
grpc
support
for
java,
and
so
this
gives
you
support
for
cover,
teens
and
and
kotlin
flows
and
other
great
features
in
kotlin.
So
I
want
to
give
you
a
quick
demo,
so
you
can
see
it.
Let's
check
it
out.
Let's
take
a
look
at
an
example
that
uses
grpc
and
kotlin.
A
You
can
find
this
on
github
under
the
google
cloud
platform,
kotlin
samples
and
then
run,
and
then
grpc
hello,
world
streaming.
There's
a
few
different
examples
in
here
we're
going
to
look
at
the
streaming
one,
and
if
you
want
to
deploy
this
up
on
cloud
run,
you
can
just
click
this
run
on
google
cloud
button
and
that
will
deploy
it
and
we'll
let
cloud
shell
start
up
and
then
go
take
a
look
at
the
source
code,
so
in
the
source
code
for
this
sample.
Let's
first
take
a
look
at
the
protofile.
A
It
takes
a
hello
request
and
it
returns
a
stream
of
hello
reply,
and
then
you
can
see
our
hello
request
and
hello
reply.
Message:
objects
down
below,
so
the
grpc
kotlin
project
will
then
generate
the
classes
to
interact
with
the
service
for
kotlin
and
let's
go
take
a
look
at
how
we
actually
use
those
generated
stubs.
A
Here
we
have
the
hello
world
server
and
we'll
start
up
the
server
and
the
the
all
that
this
server
does
is
implement
what
happens
on
that
say,
hello
stream.
So
you
can
see
it
takes
a
hello
request
and
it
returns
a
flow
of
hello
reply,
because
our
grpc
returned
that
stream
of
hello
reply
flow
in
kotlin
is
a
way
to
do
to
do
a
stream
with
non-blocking
back
pressure
and
all
that
kind
of
good
stuff.
A
So
we're
going
to
emit
a
hello
reply
and
what
we're
going
to
do
in
that
reply
is
create
a
new
hello
reply
from
the
builder
and
set
the
message
to
hello
and
then
whatever
name
came
in
the
request,
so
we're
just
going
to
emit
that
every
second.
So
that's
our
server
implementation,
nothing
very
fancy
there.
A
Then,
let's
go
take
a
look
at
the
client
that
uses
connects
to
that
server.
So
in
this
case
we're
going
to
use
the
generated
stubs
for
this
grpc
service
and
we're
going
to
to
have
a
function
in
here
called
greet
which
is
going
to
take
a
name.
And
then
it's
going
to
do
this
run
blocking
where
it's
going
to
assemble
a
hello
request
and
set
the
name
to
whatever
was
passed
in
and
then
it's
going
to
call
the
stub
say
hello
stream,
give
it
that
request,
and
this
returns
a
flow.
A
A
The
client
and
you'll
see
that
when
we
start
up
the
client
we're
going
to,
if
there
is
an
argument,
we're
going
to
use
it
an
argument
to
the
program,
if
not
we're
going
to
just
pass
in
world,
so
you'll
see
that
what
actually
then
gets
passed
in.
We
set
the
name
to
the
name
that
was
there
and
if
we
look
back
at
our
server,
it
sets
the
message
that
it's
going
to
emit
every
second
to
hello,
comma
and
then
the
name
that
was
passed
in.
A
So
let's
go
back
over
into
cloud
shell
and
I'm
actually
just
going
to
cancel
out
of
this,
where
I'm
not
going
to
go
through
the
deployment,
because
we
don't
need
to
it's
already
deployed.
And
now
I'm
going
to
run
the
client
against
my
server.
That's
up
and
running
on
cloud
run.
So
what
I'm
doing
is
I'm
taking
the
docker
container
that
was
created
if
we
had
followed
through
with
that
process
and
let
it
run
to
create
the
docker
container
from
that
source
code.
A
But
I've
already
done
that
and
then
it's
going
to
run
the
hello
world,
client
kt
application,
and
then
it's
going
to
pass
an
argument
to
the
application
which
is
the
server
to
connect
to
and
if
you'll
remember
we
take
that
argument
and
we
output
it
after
hello
every
second.
So
let's
now
run
that
docker
container
it's
going
to
go
grab
that
from
the
google
container
registry
and
download
that
to
cloud
shell
to
my
local
docker
daemon
there
and
so
that'll,
take
a
second
to
pull
that
down
and
once
that's
pulled
down.
It'll
start
up.
A
The
docker
container
run
the
hello
world
client
and
then
connect
to
our
service
running
on
cloud
run
and
remember.
Cloud
run
is
serverless,
so
it
scales
down
when
there
aren't
any
requests
and
then
automatically
scales
back
up
as
needed
and
you'll
see
that
it's
started
up
that
grpc
server
and
now
it's
outputting
every
second
hello.
With
that
argument
that
was
passed
in
so
there
we
go.
That's
our
kotlin
grpc
application
running
on
cloud
run
and
doing
a
streaming
response.