►
From YouTube: Webinar: Announcing Open Source gRPC Kotlin
Description
As developers work to modernize applications, they need foundational tools that are simple and scalable. Kotlin is now the second most popular JVM-based programming language and enables developers to build everything from mobile apps to cloud microservices. To help developers modernize with Kotlin, we’ve open-sourced gRPC Kotlin. This session will introduce the project and walk through how to use it.
Presenter:
James Ward, Developer Advocate @Google Cloud Platform
A
All
right,
I'd,
like
to
thank
everyone
who
is
joining
us
today,
welcome
today's
CN
CF
webinar,
announcing
open
source
G
RPC,
Kotlin,
I'm,
Kristy
tan
marketing
communications
manager
at
CN,
CF
I'll
be
moderating
today's
webinar.
We
would
like
to
welcome
our
presenter
today,
James
Ward
developer
advocate
at
Google
cloud
platform,
a
few
housekeeping
items
before
we
get
started
during
the
webinar.
You
are
not
able
to
talk
as
an
attendee.
There
is
a
Q&A
box
at
the
bottom
of
your
screen.
A
Please
feel
free
to
drop
your
questions
in
there
and
we'll
get
to
as
many
as
we
can.
At
the
end.
This
is
an
official
webinar
of
the
CNC
F
and,
as
such
is
subject
to
the
CN
CF
Code
of
Conduct.
Please
do
not
add
anything
to
the
chat
or
questions
that
would
be
in
violation
of
that
code
of
conduct.
Basically,
please
be
respectful
of
all
of
your
fellow
participants
and
presenter.
A
B
Thank
You
Kristy.
Thank
you,
everyone
for
joining
us
today.
So,
as
Christy
said,
I'm
James,
Ward,
I
work
at
Google
and
we're
gonna
be
talking
about
an
announcement
that
we
just
made
yesterday
about
the
open
sourcing
of
G
RPC
Kotlin.
So
I
wanted
to
start
out
with
just
a
little
bit
of
an
overview
of
Colin
for
those
of
you
that
might
not
be
familiar
with
it
and
then
do
a
little
bit
of
an
overview
of
G
RPC
and
then
we'll
get
into
the
G
RPC
Kotlin
announcement
and
please
ask
questions
as
we
go
through.
B
We
have
a
number
of
people
that
have
are
behind
this
open
source
project
also
on
today,
and
they
will
help
answer
questions
during
and
then
also
at
the
end
of
the
presentation.
So
so
ask
away
alright.
So,
let's
start
with
a
little
bit
of
an
overview
of
Kotlin
and
what
it
looks
like
if
you
haven't
seen
it
before.
Kotlin
is
a
newish
programming
language
and
it
has
a
syntax,
that's
kind
of
similar
to
Java,
and
so
this
makes
it
pretty
easy
too.
If
you're,
a
Java
developer
done
other
languages
that
have
a
similar
syntax.
B
So,
in
a
lot
of
places,
you
can
actually
leave
off
the
type
information,
and
it's
a
lot
easier
to
do
that
when
it's
not
in
the
right-hand
side
of
the
declaration
versus
the
left-hand
side
and
and
so
type
inference,
does
make
the
code
usually
look
a
lot
cleaner
and
and
easier
to
parse
and
and
looks
more
expressive
in
a
lot
of
cases.
You
do
have
to
provide
those
types
usually
on
function
parameters
and
but
they
are
optional
on
like
return
types
because
they
get
inferred.
B
B
What's
that
saying
is
that
that
configuration
may
not
be
there
it.
It's
not
necessarily
know
it
could
be
know
if
it's
coming
from
Java
and
the
the
Kotlin
type
system
will
will
handle
that
case
for
you.
But
this
is
saying
we
may
not
actually
have
a
configuration
parameter,
and
so
then
our
code
can
can
account
for
that
as
needed.
So
that's
one
nice
feature
is
having
that
no
ability
built
into
the
type
system.
Another
feature-
that's
really
great,
is
first-class
support
for
lambdas,
so
these
are
functions.
B
Inline
functions
that
you
can
specify,
as
essentially
parameters
to
a
to
another
function
or
method,
and
so
it's
really
nice
to
have
a
concise
syntax
to
you
to
define
our
functions.
This
comes
in
really
handy
in
a
lot
of
places
if
you're
doing
Kotlin
for
UI
programming,
like
an
Android,
there's
a
lot
of
callback,
things
that
benefit
from
this
syntax.
If
you're
on
the
the
server
side,
then
things
like
being
able
to
to
have
operations
that
perform
on
a
collection
or
a
stream.
B
It's
really
nice
to
have
this
lambda
syntax
for
having
those
functions
for
doing
formations
or
filters
that
kind
of
thing
one
other
nice
feature
that
I
use
a
lot
in
Colin.
Is
this
template
expression,
syntax,
where
you
can
inject
variables
into
string,
so
you
don't
have
to
do
string
plus
and
then
another
string,
and
that
kind
of
thing
you
could
just
embed
the
the
values
right
into
the
string
templates.
That's
a
nice
feature
and
then
something
that
the
a
lot
of
people
have
is
that
semicolons
are
optional.
B
So
some
other
things
that
are
a
little
bit
harder
to
point
out
in
a
simple
code
example,
but
we'll
get
into
a
little
bit
later.
Our
co-routines
soko
routines
are
for
doing
asynchronous,
concurrency
background
tasks.
That
kind
of
thing
a
really
really
nice
programming
model
around
that
they're,
also
in
Kotlin,
is
bi-directional:
interoperability
with
java,
so
you
can
call
java
objects
and
java
objects
can
call
into
Kotlin
objects
and
interesting
thing
about
Kotlin.
Related
to
this
is
that
colin
didn't
build
its
own
collections
library.
Instead,
they
use
the
Java
collections
library,
but
to
enhance
them.
B
They
use
another
language
feature
in
Kotlin,
called
extension
methods
and
extension
methods
provide
a
really
nice
way
to
interoperate.
With
Java
ap
is
the
Kotlin
syntax
is
expressive
and
concise,
and
we'll
see
that
as
we
go
through
some
examples
in
a
little
bit
and
then
it
also
the
the
way.
There's
some
language
features
in
Kotlin
the
enable
it
make
it
really
great
for
building
dsls
and
doing
typesafe
builders
and
we'll
see
some
of
that
in
a
little
bit.
B
So
why
Kotlin
it's
it's
fairly
new,
since
1.0
is
only
about
four
years
ago,
but
it
is
grown
over
time.
It
is
now
the
the
standard
language
for
building
Android
applications,
and
so
it's
getting
a
lot
of
usage
from
that.
But
it's
now
also
growing
in
other
areas
as
well
like
on
the
server
side.
There's
great
support
in
java
web
frameworks
like
spring
boot
for
Kotlin
and
a
number
of
other
web
frameworks
and
and
restful
frameworks
that
have
great
support
for
Kotlin
as
well
and
just
at
last
fall.
B
Kotlin
became
the
number
two
most
used:
jvm
language
behind
java,
of
course,
and
then
scala
behind
that
side,
overtook
scala
on
that
list.
So
a
lot
of
great
energy
around
around
Colin,
another
example
that
I
find
pretty
compelling
and
something
that
I
really
love
in
Colin
is
that
in
Java
we
used
to
have
to
use
javabeans
syntax
to
write
out
our
data
classes.
Our
ability
to
hold
data
in
an
object
and
you'd
have
to
generate
the
getters
and
setters
and
equals,
and
hashcode
and
yeah
your
ID.
B
You
can
generate
those
for
you
and
your
to
string,
but
it
sure
is
nice
to
have
a
concise
syntax
for
defining
these
types
of
data
classes
that
have
values
on
them
and
the
to
string
and
equals,
and
hashcode
methods
are
all
generated
by
the
compiler
and
that's
just
a
data
class
in
column.
So
that's
something
that
that
I
use
a
lot
makes
my
code
a
lot.
A
lot
cleaner,
easier
to
read.
B
Okay,
so
we'll
see
a
lot
more
Kotlin
in
a
couple
minutes,
but
let's
go
on
to
G
RPC,
so
G
RPC
combines
together
a
couple
different
pieces.
The
first
piece
is
protocol
buffers
and
protocol
buffers
are
a
nice
declarative
way
to
define
messages
and
services,
and
then
what
we
can
do
is
take
this.
This
declarative
definition
of
our
messages
and
services
and
we
can
then
wrap
services
around
those
things
actual
services
that
we
run
and
interact
with
so
the
protocol
buffers.
B
They
are
language
agnostic,
so
we
define
them
in
one
declarative
format
and
then
what
we
do
is
we
generate
from
that
declarative
format,
the
different,
what
are
called
stubs
that
we
can
interact
with
in
Java
or
now
in
Kotlin
or
in
JavaScript
or
whatever?
So
so.
The
nice
thing
is
we
have
that
language,
agnostic
definition
that
allows
us
to
communicate
between
different
things
without
having
to
write
our
parsers
and
our
data
objects
and
all
that
in
in
multiple
languages.
B
Protobufs
also
support
has
great
support
for
evolving
protocols.
So
if
we
want
to
add
fields
to
a
message,
we
can
do
that
and
not
things
they're
also
strongly
types.
This
gives
us
a
strongly
typed
representation
of
our
transport
protocols,
and
so
it's
nice
to
have
that
over
Jason,
which
obviously
doesn't
have
any
strong
typing
to
it.
B
So
what
we
do
with
with
our
protocol
buffers
is,
we
generate
our
serializers
and
deserialize
errs
for
our
messages,
those
get
generated
by
the
protobuf
proto
C
compiler,
which
we'll
see
in
a
little
bit,
and
then
we
also
generate
our
service
stub.
So
you'll
see
that
in
this
example,
I've
defined
a
greeter
and
it
has
an
RPC
service.
So
it's
something
that
takes
an
input
and
returns
an
output
of
those
those
messages
and
that
what
this
will
do
is
generate
the
client
and
the
server
to
be
able
to
use
that
service.
B
So
generally,
we
generate
both
of
those
and
then
we
get
superfast
Network
our
PC.
So
the
reason
why
we
get
superfast
network
RPC
is
one
that
the
protobuf.
The
protocol
is
very
concise
and
that's
nice,
but
also
G
RPC
is
built
on
top
of
HTTP
2
and
HTTP.
2
brings
with
it
a
bunch
of
great
features
for
doing
this
very
optimized
communication
between
a
client
server,
so
it
uses
by
O'brien
Airy
protocol,
which
is
allows
us
to
be
much
more
concise.
It
has
a
stream
support,
so
we
don't
need
to
use
WebSockets.
B
We
we
have
native
Stream
support
in
HTTP
to
we
can
do
stream
multiplexing,
so
we
can
do
multiple
channels
of
communication
over
a
single
connection
and
then
it
has
other
features
like
header
compression
to
save
bandwidth
and
that
sort
of
thing.
So
so
that
is
our
quick
rundown
on
Kotlin
and
G
RPC,
and
the
announcement
that
we
made
yesterday
was
open
sourcing,
G,
RPC
Kotlin,
and
what
that
is
is
bringing
together
these
two
great
great
technologies.
So,
let's
run
through
a
little
bit
about
what
it
is
and
then
we'll
we'll
see
it
for
real.
B
B
This
is
built
on
top
of
G
RPC
Java,
so
we're
we're
building
on
top
of
that,
because
there
is
still
a
bunch
of
Java
underneath
the
covers
for
a
lot
of
this
stuff,
and
so
we
build
on
top
of
that
and
add
the
Kotlin
friendly
pieces
on
top.
But
we
can
then
add
support
for
nice
things
in
Kotlin,
like
co-routines,
for
doing
async
and
then
also
the
flow
api,
which
is
a
stream
oriented
API.
So
co-routines
is
a
a
metaphor
as
a
way
to
do
an
async
callback,
so
you're
gonna
go,
do
something.
B
B
B
If
there's
any
questions
that
came
in
so
far,
the
that
need
answering
now
feel
free
to
chime
in
okay.
So,
let's
start
with
our
very
simple
hello
world
example:
hair
I've
got
my
my
Gradle
project
and
I
have
defined
some
versions
for
things.
I
am
including
the
protobuf
Gradle
plug-in
and
the
Kotlin
Gradle
plug-in
so
that
this
project
knows
how
to
support
Kotlin
and
and
knows
how
to
generate
protobufs.
B
So
then
I'm
going
to
apply
those
plugins
now
I
do
need
to
include
the
G
RPC
Collins
stub,
and
this
is
part
of
what
we
need
to
be
able
to
once.
The
code
is
generated.
There
are
some
dependencies
in
that
generated
code,
and
this
is
where
those
come
from
then
we're
gonna
include
our
Kotlin
standard
stuff.
B
We're
gonna
include
our
protobuf
and
your
RPC
standard
stuff,
so
you'll
see
the
protobuf
Java
Porter,
both
Java
util
I'm,
using
Neddie
witchy
RPC
is
the
actual
server
and
client
HTTP
implementation,
and
then
we
get
into
our
protobuf
configuration
where
we
are
going
to
have
a
plug-in
to
the
proto
C
compiler,
which
is
going
to
do
the
Java
prota
C
compliation,
and
then
we're
going
to
also
do
the
Kotlin
one.
So
we
do
both
of
those
and
then
there's
a
little
bit
more
configuration
than
this,
but
but
that's
kind
of
it.
Okay.
B
So
then
I've
got
my
protobuf
definition,
my
protobuf
definition.
I
have
to
find
my
service
very
similar
to
what
you
saw
before
this
is
an
RPC
called,
say,
hello.
It
takes
in
an
input
of
hello
requests
and
returns
an
output
of
hello
reply.
So
then
we
can
see
our
messages
here.
Hello
request
has
a
name
and
hello
reply
has
a
message.
So
that's
our
declarative,
protobuf
for
our
g
RPC
service.
Then,
let's
go
over
to
our
server
and
our
server
is
written
and
Colin
and
there's
some
work
here.
B
That
is
just
starting
up
the
server
listening
on
and
doing
that
sort
of
thing
and
handling
shut
down.
The
interesting
piece
of
this
is
that
I'm
extending
the
greeter
GRP
ckt
and
the
greeter
co-routine
imple
base,
and
so
that
was
generated
from
my
my
protobuf
and
now
I
create
an
instance
of
this
class
and
I
override
the
say,
hello
method
and
it's
going
to
be
take
the
same
parameters
just
that,
the
that
the
interface
had
which
it
came
from
that
protobuf
it's
going
to
take
in
a
hello
request
and
return.
B
B
I'm
gonna
use
the
Builder
for
it
I'm
going
to
set
the
message
in
that
hello
reply
to
say
hello
and
then
whatever
the
name
that
came
in
the
request
was
and
then
I'm
gonna
build
that
and
you'll
see
that
build
returns,
a
Hello
reply
and
so
that
there
I've
implemented
my
simple
server.
So
I'm
gonna
start
the
server
up
so
that
we
can
see
this
thing
actually
work.
So
you
see
it's
up
and
running
listening
on
that
port
and
then
let's
go
take
a
look
at
our
client
so
for
our
client.
B
Let's
first
go
down
to
our
main
method
and
I
have
to
do
a
little
bit
of
setup
here
to
connect
to
the
server.
So
here's,
where
I'm
doing
my
message
channel
builder,
giving
it
the
server
that
I
want
to
connect
to,
in
my
case,
just
localhost
in
that
port
and
then
I'm
going
to
tell
it
create
my
hello
world
client,
and
so
this
was
part
of
the
code
that
we'll
see
in
in
a
minute
and
then
we're
going
to
figure
out
what
we
want
to
send.
B
And
if
there
was
an
argument
to
this
program,
then
I'll
use
that
otherwise
I'll
just
use
world,
and
now
we
call
the
hello
world
client
dot,
greet
method
and
give
it
this
string
user.
So
let's
go
take
a
look
at
that
and
see
what's
in
there.
So
we've
got
our
hello
world
client
it
takes
in
a
parameter
of
channel
and
which
is
closeable
and
then
we're
using
our
stub.
B
That
was
generated
from
the
protobuf
definition
and
now
we've
got
this
function,
greet
which
takes
in
a
name
string
and
then
because
we
are
using
co-routines
where
we
need
to.
In
this
case,
we
want
to
just
run
this
thing:
send
it
the
the
message,
get
the
response
and
then
exit,
and
so
the
way
in
this
case,
instead
of
doing
a
suspend
fun,
is
we're
just
going
to
say
block
on
on
this
thing,
run
blocking
and
we're
going
to
assemble
our
request.
So
we're
going
to
use
that
builder.
B
That
generated
builder
set
the
name
to
the
name
that
we
got
in
and
then
we're
going
to
use
our
stub,
which
is
our
way
to
communicate
with
that
server.
We're
gonna
call
the
say,
hello
method,
give
it
our
request
and
then,
when
we
get
the
response
back,
which
is
asynchronous
but
because
we're
in
run
blocking
it's
going
to
automatically
await
this
result
for
us
and
in
a
non
blocking
way,
and
then
it's
going
to
get
the
message
out
of
the
response
and
output
that
so
that's
our
very
simple
hello,
world
client.
B
Let's
run
this
thing
and
see
it
actually
work.
So
there
we
go.
We
now
see
that
the
greeter
got
a
message
back,
which
was
hello
world
which
came
from
the
server
which
combined
the
string
world
and
prepended
hello
on
in
front
of
that
so
very
trivial,
simple
example
there.
But
hopefully
that
gives
you
a
quick,
quick
rundown
of
how
to
start
building
a
G
RPC
Kotlin
application
with
G
RPC
Colin.
B
Now,
if
we
didn't
want
to
go
see
some
of
the
code
that
is
generated
by
the
proto
C
plug-in,
we
can
come
in
here
and
look
at
our
generated
source
and
go
into
proto
and
see
the
different
generated
targets
from
our
build.
There's
the
greeter
GRP
see
here's
the
Kotlin
piece,
a
piece
that
was
generated
and
some
some
Java
that
was
generated
here
with
our
our
actual
value
objects.
Our
hello
apply
hello
requests
and
the
builders
for
those
okay.
C
B
Awesome
Thank
You
Brent
and
thanks
David
for
chiming
in
good
to
have
you
you
here
helping
okay,
so
we've
got
our
basic
hello
world
example
and
I'm
going
to
close
those
down
because
we're
going
to
continue
on
with
the
the
next
example
here,
which
is
a
maven
example
and
I
wanted
to
show
you
what
the
maven
build
looks
like
for
this
same
sort
of
project.
So
if
you
are
using
maven
instead
of
Gradle,
that's
great,
you
can
use
the
same
the
same
sort
of
thing
to
be
able
to
do
this.
B
B
Ok,
then,
of
course
we
have
the
Colin
compiler
plug-in
in
here
as
well,
so
I
won't
run
through
the
proto
and
code
on
this
one,
because
it's
the
exact
same
as
what
you've
already
seen,
but
I
will
share
at
the
end
the
link
to
go
get
all
of
these
samples.
Okay,
so
that's
the
the
maven
palm
build.
Now,
let's
go
on
to
the
next
example
and
for
this
one
we
are
doing
streaming.
So
in
this
case,
we
are
doing
server
streaming.
B
B
B
So
that's
our
server
implementation
and
then
let's
go
take
a
look
at
our
client,
so
for
our
client,
what
we're
gonna
do
is
again
we're
gonna
run
blocking,
because
this
is
just
going
to
to
do
its
thing
and
then
exit
and
so
we're
going
to
create
our
request,
just
like
we
did
before,
but
this
time
when
we
call
that
stub,
say
hello
stream
and
give
it
the
request.
What
we
actually
get
back
is
a
flow,
and
so
then
we
can
do
all
sorts
of
flow
operations.
B
On
this
thing,
one
of
the
flow
operations
is
called
collect.
What
collect
does
is
every
time
there
is
a
an
element
emitted
from
this
flow.
You
can
have
a
lambda
function.
That
then,
does
something,
and
in
our
case
very
trivially,
we
are
going
to
just
print
out
that
message
so
and
then
the
rest
of
this
looks
very
similar
to
what
you
saw
before.
B
Okay,
so
so
we've
got
our
server
streaming
example
and
I
didn't
want
to
show
you
that
I
could
run
this
locally,
but
I
did
want
to
show
you
that
this
all
does
work
on
cloud
services
as
well,
and-
and
we
have
a
cloud
service
that
runs
is
great,
which
is
called
cloud
run,
and
so
in
our
example.
This
is
the
GRP
see
hello
world
streaming
example.
You
can
deploy
this
on
cloud
run
and
that
will
deploy
create
a
docker
container,
deploy
that
docker
container
on
the
managed
cloud
run
service.
B
You
could
also
deploy
that
container
on
kubernetes
or
other
places
that
run
containers
and
now
I've
already
done
that
piece
and
deployed
that
application.
So
it's
all
up
and
running
here
on
cloud
run,
and
so
that's
that's
great
that
the
it's
up
and
running
on
the
cloud,
but
now
we
need
a
way
to
run
our
client
to
call
it,
and
so
I'm
gonna
go
over
into
cloud.
B
Shell
and
I've
already
set
this
up
so
that
I
can
just
do
the
docker
run
and
then
I
need
to
give
it
the
parameter
of
the
server
to
connect
to
and
because
it
doesn't
know
about
what
the
what
the
endpoint
for
that
server
is
so
I
have
to
tell
it
and
then
I'm
going
to
give
it
my
docker
container
that
I
created,
which
has
both
the
server
app
and
the
client
app
in
it.
And,
of
course
you
could
create
your
docker
containers.
B
However,
you
want,
but
I
put
them
both
into
a
single
docker
container
and
then
I
give
it
a
parameter
to
say
which
process
I
want
to
run,
and
in
this
case
I'm
gonna
run
the
client,
and
so
now
that
will
go
get
the
docker
container
run
it
with
that
parameter,
and
it's
gonna
run
that
client
that
we
were
just
looking
at
so
it's
gonna
run
this
client
that's
going
to
make
that
request,
but
get
the
stream
back
and
then
output
the
result.
So,
let's
go
over
back
to
our
cloud.
B
Shell
and
you'll
see
that
now
sure
enough,
our
server
is
responding
with
a
stream.
That's
that's
emitting
a
value
once
a
second
that's
taking
in
our
case
the
name
that
I
gave
it
was
just
the
server
name
that
we
were
connecting
to,
but
you'll
see
that
now
it's
outputting
that
once
a
second,
so
it
just
will
continually
stream
that
output.
Okay.
So
that's
our
server
streaming
example
and
and
runs
great
on
cloud
run
or
other
places
that
can
run
containers
or
really
anywhere
that
can
run
a
G
RPC
server.
B
Let's
take
a
look
at
our
last
example
now,
which
is
taking
this
a
little
bit
further,
so
we
could
also
have
a
service
that
does
client
streaming.
So
in
a
client
streaming
example,
we
would
take
in
a
stream
and
then
just
return
a
single
value,
but
in
this
case
we
want
to
do
to
show
bi-directional
streaming
where
our
RPC
takes
in
a
stream,
but
then
also
returns
a
stream,
and
so
let's,
let's
look
at
the
server
for
this
one.
So
our
server
implements
that
function.
That
takes
a
flow
of
flow
requests
and
returns.
B
An
element
emits
on
this
requests
then
do
something
with
it,
and
so
what
I'm
going
to
do
is
I'm
going
to
print
it
and
then
I'm
going
to
create
a
hello
reply,
and
this
will
just
automatically
get
returned,
and
so
that
now
has
transformed
my
flow
of
flow
requests
into
a
flow
of
hello
reply,
and
so
I've
done
my
my
stream
transformation.
All
the
rest
of
this
code
looks
the
same
as
what
you're
familiar
with,
and
so
this
is
kind
of
like
a
echo
echo
service,
and
so
then,
on
my
client
side.
B
I
need
to
give
this
thing
a
flow,
so
I'm
going
to
assemble
a
flow
and
very
similar
to
what
you
saw
before
my
flow
is
going
to
once
a
second
emit,
a
value
which
is
going
to
be
my
hello
request,
and
so
now
this
is
a
flow
of
hello
requests
and
let's
go
start
up.
Our
server
get
that
run
in
while
we're
waiting.
While
we
go
through
the
rest
of
this
okay.
B
B
It
runs
in
a
co-routine
scope
and
you'll
see
that
I'm
calling
my
stub
say
hello
stream
I'm,
giving
it
my
my
hope,
flow
of
low
request
and
then
every
time
I
get
an
element,
a
response
I'm
just
going
to
print
it
so
very
simple
examples
here,
but
hopefully
it
helps
give
you
the
the
gist
of
using
G
RPC
with
Colin.
So
let's
run
this
one
make
sure
that
it
works.
So
there
we
go.
B
We
see
a
hello
world
repeating
every
second,
so
now
now
that's
a
bi-directional
string,
because
my
client
has
producing
a
stream,
that's
going
to
the
server
being
transformed
and
then
being
sent
back
to
the
client,
and
so
there
we
go
by
directional
streaming
there
with
with
Colin
and
gr
PCM.
Okay.
So
those
are
the
four
examples
that
I
want
to
show.
You
and
I'll
give
you
some
information
on
where
to
find
all
those.
B
So
this
is
all
in
the
slides,
but
we
saw
the
code
in
IntelliJ,
so
the
best
place
to
learn
how
to
get
started
is
in
the
G
RPC
Docs.
You
can
go
to
the
quick
start
for
Kotlin
and
great
documentation
there.
If
you
do
want
to
check
out
those
those
four
samples
that
I
showed
you,
those
are
on
the
Google
cloud
platform,
github
and
then
under
common
samples
and
then
they're
in
a
directory
called
run.
Because
those
are
the
cloud
run
examples.
B
A
Thanks
James
for
a
great
presentation
and
demo:
oh,
this
is
great.
Okay,
so
I'll
go
ahead
and
read
that
question
and
we'll
go
ahead
and
dig
in
here
and
so
I'm
probably
butchering
this,
but
shirisha
asks
I
am
looking
into
the
github
repo
of
G
RPC
Kotlin.
How
can
we
start
contributing
to
it?
I
guess
you
would
just
answered
that
through
the
docs
rate
for.
B
Actually
contributing
which,
of
course,
we
would
love
contributions.
We
open-source
this
so
that
so
that
we
can
get
everyone
involved
in
making
it
better,
and
so
that
is
actually
on
github,
calm,
/g,
RPC
and
then
gr,
PC
Kotlin
and
yes,
we
would
certainly
love
contributions
to
that
that
repo,
and-
and
so
that's
where
the
source
code
for
the
stub
that
I
pointed
out
as
a
dependency
and
then
the
proto
C
plug-in
all
the
code
for
that
stuff
is,
is
all
in
that
repo.
So
certainly
would
love
contributions.
I'm
I'd.
D
Like
to
china
chime
in
right,
there
also
and
just
say,
probably
the
best
way
that
you
can
help
is
to
use
the
library
and
give
us
feedback
and
report
bugs
or
issues
if
you
find
them,
and
also,
of
course,
fix
those
issues.
If
you
feel
so
inclined,
and
we
do
have
a
running
list
of
issues
on
that
repo,
that
would
be
happy
if
anyone
wanted
to
to
give.
A
B
B
E
Yeah
yeah
just
turn
them
into
by
cool,
hey
I,
think
your
PC
isn't
single
messages
might
have
a
cap
I
think
it's
above
a
megabyte
now,
but
you
risk
using
ours.
You
turn
it
into
a
stream
and
concatenate
them
and
send
those
messages
and
put
them
back
together
on
the
client,
which
should
work
quite
well
with
the
flows.
E
B
A
good
point:
I
I,
would
guess
that
there
is
a
way
to
go
from
a
input
stream
in
Java
to
a
flow
and
Kotlin.
That's
I
haven't
looked
in
that
in
particular,
but
I
guess
that
there
is,
and
if
there
is
then
yeah,
you
could
read
your
file
into
an
input
stream
and
then
turn
it
into
a
flow
and
then
stream
it.
But
if
anyone
wants
to
try
it,
and
if
you
have
problems,
then
please
file
issues
on
the
gr
PC
Kotlin
repo
with
that.
A
A
B
For
for
me,
I
do
most
of
my
programming
on
the
JVM,
and
so
so
Cotton's
ability
to
to
interoperate
with
Java
and
be
on
the
JVM
is
certainly
good
for
me.
There's
also
a
lot
of
really
nice
functional
programming,
oriented
features
in
Kotlin
that
I
really
enjoy
when
I
take
that
really
far.
There's
a
functional
programming,
library
and
Kotlin
called
arrow,
which
is
really
nice.
E
Nothing
immediately
comes
to
mind,
I
mean
I,
can
think
of
one
or
two
things.
I
might
change
about
coming
to
answer
the
last
part
of.
E
Mostly
Feder
said
static
analysis,
plugging
points,
but
that's
all
I
can
think
of
girl.
C
A
B
Yeah,
so
the
the
the
biggest
dependency
is
in
really
any
continent
application.
That's
on
the
JVM
is
going
to
be
the
JVM
itself,
and
so
I
was
actually
just
exploring
container
layer
sizes
recently
and
and
found
that
that
about
as
small
as
I
could
get
a
Kotlin
JVM
based
application
was
about
150
Meg's.
A
very
small
portion
of
that
is
the
the
generated
code
and
the
the
stubs,
and
so
really
a
lot
of
that
is
actually
in
the
JVM
itself.
There
is
a
technology.
The
Oracle
is
working
on
called
growl,
VM
and
growl.
B
Viim
allows
you
to
take
a
Kotlin
or
Java
or
Scala
any
JVM
application
and
compile
it
down
into
native
code,
doing
ahead
of
time
compilation
and
when
I
did
this
on,
it
wasn't
a
common
project,
but
but
I
think
you
could
find
similar
effects.
I
did
this
on
a
scholar
project
recently
and
my
output
binary.
B
It
just
takes
a
little
bit
of
configuration
where
you
have
to
specify
any
reflection
information
through
a
configuration
file,
but
you
can
generate
that
that
reflection
mostly
generate
that
reflection,
config
file
using
dravyam
and
so
so
something
worth
looking
into
and
as
we
explore
that
we
will
be
sharing
that
on
my
Twitter
and
and
other
places
as
well
for
doing
gr
PC
in
crawl.
That's
fun,
fun
thing
that
I
will
be
looking
into.
So
thanks
for
that
question.
B
You
can
do
reflection,
you
just
withdraw
VM.
You
just
have
to
have
a
configuration
file
that
specifies
the
reflection,
information
and
so
I
I
did
this
on
a
project
recently
and
let
me
actually
go
see
if
I
can
show
it
to
you.
So
this
is
a
project
that
does
a
lot
of
reflection.
I
think
there
is
even
some
protobuf
stuff
in
this
particular
one,
and
so,
if
we
go
look,
I'll
show
you
the
I'm
gonna
get
hub.
B
The
configuration
file
for
the
reflection
you'll
see
that
this
is
all
the
information
that
specifies
all
the
reflection
that
happens,
and
so
so
it
certainly
was
possible
and
most
of
this
file
was
generated
for
me,
but
there
were
a
few
places
where
I
had
to
to
do
some
manual
tuning
of
this
file
to
get
it
all.
I'll
work
in
crack,
so
you'll
see
there's
some
comm
Google
Commons
some
stuff
in
here
that
was
being
used.
So
so
it
is
possible.
I
haven't
done
it
on
a
gr,
PC
application.
B
A
B
Frameworks
that
do
speak,
the
g,
RPC
protocol,
I
I
think
most
people
that
are
doing
G
RPC
are
just
using
the
out-of-the-box
gr
PC
Nettie's
server,
but
but
yeah
there.
There
are
other
frameworks
that
do
speak:
G,
RPC,
so
I,
don't
I,
don't
know
specifics
on
that.
I
don't
know
if
I'd
be
also
knows
knows
more
about
that
Brent
ER.
This.
A
Okay,
next
question
from
Peter
does
gr
PC
support
back
pressure.
Do
sorry
using
this
flow
API
yeah.
E
B
E
B
E
A
E
The
answer
is
no
and
I.
Think
a
part
of
that
is
the
last
time
I
checked
on
Kotlin
X
serialization
when
it
says
cut
line,
X
serialization
supports
protobuf.
What
they
mean
is
that
they
support
using
protobuf
as
the
like
serialization
in
terms
of
how
the
messages
is
stored
and
converted
into
bytes,
but
not
necessarily
in
terms
of
how
messages
defined
in
terms
of
how
the
message
evolves
and
certainly
not
in
terms
of
the
proto-language
job
profiles
or
thing.
That's
not
that's.
What's
currently
supported,
Sakhalin
ex
serialization
doesn't
currently
work.