►
Description
Join us for Kubernetes Forums Seoul, Sydney, Bengaluru and Delhi - learn more at kubecon.io
Don't miss KubeCon + CloudNativeCon 2020 events in Amsterdam March 30 - April 2, Shanghai July 28-30 and Boston November 17-20! Learn more at kubecon.io. The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects
Cloud native programming inherently involves working with remote network endpoints: microservices, serverless, APIs, WebSockets, SaaS apps and more. Ballerina is a programming language that is designed to make coding network constructs an inherent part of the language, and to bring code-first agility to the challenge of integrating across endpoints. Ballerina has first-class support for distributed transactions, circuit-breakers, stream processing, data-access, JSON, XML, gRPC and many other network endpoints. It deploys directly onto Docker and Kubernetes. It integrates with common IDEs including IntelliJ and Visual Studio Code. Sequence diagrams can be automatically generated from code. Ballerina is an open source project in Github.
In this talk Paul will explore Ballerina features and development – most of the talk will be a live demo together with some discussion of the motivation for creating a new programming language and the design inspirations. You can find out more at https://ballerina.io and https://github.com/ballerina-platform/ballerina-lang
A
Alright
looks
like
our
numbers
are
stabilizing,
so
let's
go
ahead
and
get
started.
Welcome
to
today's
cncs
webinar
intro
to
ballerina,
I'm,
Kaitlin,
Barnard
marketing
manager
at
CNCs
and
I'd
like
to
thank
everyone
for
joining
us
today,
as
well
as
today's
presenter,
Paul,
Fremantle,
CTO
and
co-founder
of
wso.
A
So
just
a
few
housekeeping
items
before
we
get
started
during
the
webinar
you're
not
able
to
talk
as
an
attendee.
So
there
is
a
Q&A
box
at
the
bottom
of
your
screen.
So
please
feel
free
to
drop
any
of
your
questions
in
there
and
we'll
get
to
as
many
as
we
can.
At
the
end,
the
session
is
also
being
recorded
and
will
be
sent
out
afterwards,
along
with
the
slide
the
slides
and
link
to
the
presentation.
So
with
that
I'll
hand
over
to
Paul
to
kick
off
today's
presentation.
B
Thank
you
very
much.
Caitlin
hi
everybody
thanks
for
taking
the
time
to
join
us
for
this
webinar,
so
the
the
presentations
actually
mainly
give
me
a
live
demo.
Hopefully
that
will
all
work,
but
before
I
jump
into
that
I
just
want
to
spend
about
three
minutes
just
explaining
why
we
built
a
language
which
is
obviously
a
question.
People
ask
so
I
think
that's
that's
kind
of
important
to
sort
of
help.
B
You
understand
that
the
motivations
and
the
purpose
in
this
language-
and
so,
let's
just
sort
of
start
by
looking
at
the
overall
industry,
especially
around
the
software
and
and
what
we
see
is
that
there's
this
massive
disaggregation
of
systems-
and
this
is
really
driven
by
customer
demand-
customer
demand
for
bigger
scale
services.
You
know
Google
Netflix,
Amazon
Alibaba
and
also
get
customer
demand
for
agility
for
people
to
move
quicker,
to
create
new
capabilities
faster
than
that
agility
and
scale.
B
B
Api
is
micro-services
data
as
a
service,
SAS
apps
everything
is
becoming
a
programmable
endpoint,
and
so
increasingly,
when
we
built
old
applications,
we
are
not
just
building
systems
that
live
on
their
own,
but
we're
building
systems
that
have
to
integrate
and
talk
to
network
program,
all
endpoints
and
every
every
developer
I
know
is,
is
creating
systems
that
are
talking
to
other
network
api's
and
endpoints,
and
so
as
we
do,
that,
you
know
there
are
challenges
distributed.
Computing
is
not
the
same
as
local
computing
and
and
typically
historically,
we
called
this
art
of
writing
distributed
applications.
B
We
call
it
integration
and
there
are
challenges
to
integration.
They're
distributed
transactions.
There
are
patterns
like
circuit
breakers,
there's
protocol
handling,
there's
security,
there's
error
handling.
All
these
challenges
make
writing
distributed
computing
systems
harder
than
locally
based
computing
systems,
and
that
are,
and
science
of
creating
distributed.
Computing
systems
has
typically
been
done
in
one
of
two
ways.
So
my
background
is
I,
worked
on
a
whole
bunch
of
integration
products,
I
I've
built
early
es
B's
in
open-source
and
at
various
companies.
I've
worked
on
Business
Process
Management
I've
worked
with
Inter
product
creation
hubs.
B
These
integration
products
inherently
understand
the
challenges
of
distributed
computing
and
have
things
like
circuit
breakers
load,
balancers
failover
compensation,
all
those
kind
of
things
payload
handling
built
in,
but
they
have
a
big
problem,
which
is
that
they
don't
fit
neatly
and
nicely
into
a
developer,
focused
agile
iterative
development
process.
They
don't
fit
into
that.
You
know
code
build
run
test
cycle
that
we
go
through
as
developers,
so
the
other
approach
is
to
take
a
general-purpose
programming
language
and
then
try
and
then
build
distributed
systems.
B
And
when
you
do
that,
you
you
have
you
have
a
choice.
You
either
write
the
code
yourself
to
handle
those
those
error
cases,
those
distributed
systems
or
you
import
a
framework
and
and
when
you
do
that,
you
take
responsibility
for
solving
those
integration
challenges,
and
so
we
believe
that
those
general-purpose
languages
are
perhaps
not
as
integration
simple
as
they
could
be,
and
the
integration
products
are
not
as
agile
as
they
could
be.
B
So
we
call
this
integration
gap,
there's
a
there's,
a
sort
of
a
space
there,
and
we
decided
that
perhaps
one
way
of
solving
that
was
to
create
a
language
that
inherently
tried
to
address
integration
distributed
computing
and
network
computing
concepts
in
the
language.
But
it's
a
full
language
that
fits
well
into
an
agile
development
process
and
that's
Ballerina
and
the
easiest
way
to
explain
it
is
to
is
to
just
show
you
some
code,
so
I'm
gonna
just
jump
in
and
start
coding.
It's
a
compiled,
typesafe
concurrent
programming
language.
B
So
it
doesn't
use
it's
not
it's
not
a
it's,
not
a
dynamic
language,
but
it
it
looks
similar
to
dynamic
languages.
It's
not
it's
not
particularly
complex,
and
it
has
a
lot
of
concurrent
constructs
which
are
very
important
to
the
to
the
handling
of
network
aspects.
So
the
way
I'm
going
to
do
that
is
I
have
Visual
Studio
code
installed
in
my
in
my
system
and
I've
installed.
B
Ballerina
and
the
only
other
thing
I
have
installed
is
I,
have
docker
and
kubernetes
run,
which
I'm
going
to
use
for
some
of
the
demos
and
I
had
a
couple
of
things
on
the
cloud
that
I
hope
to
get
to
as
well
so
I'm
going
to
start
up
a
new
Ballerina
file
and
this
your
studio
code
has
got.
Thee
has
already
imported
the
plug-in
for
that.
So
that's
start
by
writing
a
hello
world.
B
That
knows
that
you
start
up
in
Maine
and
then
you
go
and
start
some
listener
and
then
and
the
thread
pool
and
everything
else
in
ballerina
the
concept
of
a
listener.
A
service
is
built-in
and
those
can
be
aged,
pea
listeners,
GOP,
C
Kafka.
They
can
react
to
messages
and
Kewpie
all
sorts
of
different
protocols.
B
B
There's
a
ballerina
command
and
I'm
gonna
build
that
demo,
bowel
and
that's
gonna,
create
a
balik's
and
I'm
gonna
just
run
that
so
ballerina
has
a
bytecode
and
a
bytecode
virtual
machine,
so
I'm
gonna
use
that
to
run
this
bytecode
and
now
it's
listening
on
port
1990
I'll
explain
that
code
in
a
second
in
a
bit
more
detail,
but
I
just
thought
it
was
be
useful.
Just
to
show
you
service
running
and
we've
got
two:
we've
got
a
service
and
a
resource
within
that
service,
and
so
by
default.
B
B
This
arrow
indicates:
there's
a
network
called
happening
here,
so
the
syntax
instantly
is
showing
us
that
we
have
a
network
interaction
going
on
here
and
I
think
this
is
really
interesting,
because
one
of
the
you
know
famous
things
is
that
the
fallacy
of
distributed
computing
is
it's
the
same
as
local.
Within
this
language,
you
can
clearly
see
when
you're,
making
remote
calls,
because
they
they
appear
in
the
syntax,
and
this
also
has
some
semantic
meaning
as
well.
B
So
it's
not
just
about
the
syntax,
the
semantics
meaning
I'm
going
to
come
back
to
in
a
little
bit,
and
then
this
underscore
equals
for
every
function.
That
returns
a
value.
You
have
to
deal
with
the
return,
even
if
you
just
say
I,
don't
want
to
deal
with
it.
So,
in
this
case,
this
is
the
server
responding
back
to
the
caller.
If
there's
an
error
at
that
point,
then
there's
not
much.
We
can
do
apart
from
log
it
because
we've
already
lost
the
connection
to
the
to
the
from
the
client.
B
So
in
this
case
I
am
gonna,
just
drop
it.
So
there
we
go
now.
That's
basically
the
same
code
that
I
showed
you
before
I've
just
been
a
bit
clearer
about
what's
going
on,
but
I
probably
want
to
not
just
have
this
hello
hi
path
that
was
running
so
what
I
can
do
is
I
can
annotate
this
service
with
a
config
and
I
can
set
a
base
path.
B
B
We're
gonna
pass
and
I'm
gonna
say
it's
a
string,
and
this
is
the
body
of
the
message
coming
in
so
I
can
actually
grab
that
string
and
now
do
that
now
you
can
bind
JSON
XML
different
data
types
and
there's
also
mapping
from
JSON
into
into
the
record
an
object
types
of
ballerina,
but
that's
probably
a
bit
complex
to
go
into
right
now.
But
this
is
kind
of
nice.
B
Now
just
explained
this
to
you
what's
interesting.
Another
thing
about
network
programming
is:
we
all
know
that
there
are
challenges
with,
for
instance,
sequel
injection
attacks,
so
people
can
pass
over
tainted
data
over
a
network
connection,
especially
in
an
HTTP
POST
or
a
G
RPC
body,
and
so
what
Ballerina
does?
Is
it
just
implicitly
assumes
that
all
data
coming
from
the
wire
is
tainted,
and
so
it's
got
taint
checking
built
into
the
language
which
is
which
is
pretty
unique.
B
There's
a
couple
of
languages
that
have
considered
this,
but
we
think
we
think
this
is
pretty
much
the
only
language
that
is
built
it
right
into
the
language
from
day
one
now
I'm
just
doing
a
demo,
so
I'm
going
to
explicitly
untain
that
and
say
well
I'm,
just
responding
back
to
you.
If
you
want
to
see
your
tainted
data,
you
can
have
that.
So
in
this
case
we
can
just
done
taint
it.
B
But
normally
you
might
do
something
like
you
might
say:
string
clean
body,
equals
intent
and
then
body
dot
replace
and
then
you
can
use
a
red
X
to
clean
out
any
any
problems.
So
you
can
see
how
that
would
work.
So
we've
now
got
a
parameter
being
passed,
we've
got
a
post
required.
We've
changed
the
path
so
done.
Some
useful
things
I'm
going
to
rebuild
that,
hopefully
have
any
syntax
errors
and
I'm
gonna
run
that
and
now
I
don't
need
that
path.
B
What
have
I
done
there
I
know
what
I've
done.
I
have
failed
to
tell
me
that
the
body
is
going
to
be
this
parameter,
so
I
need
to
bind
the
body
of
the
message
to
this
parameter
here.
So
I
always
make
mistakes
in
life,
demos
you
can
see
what
I'm
doing
there.
So
let
me
try
and
run
it
and
now
hopefully
there
we
go
so
very
quickly.
You
can
see.
We've
done
some.
Some
simple
network
programming,
but
I
want
to
do
more.
I
want
to
now
call
another
network
service.
B
Now
there's
two
ways:
I
could
do
that.
I
can,
for
instance,
just
create
an
HTTP
client
and
do
HTTP
gets.
That
would
be
very
natural,
and
that
will
be
easy,
but
I
can
also
go
and
use
some
connectors
and
so
I'm
going
to
go
and
search
and
see.
If
there's
a
Twitter
connector
now
ballerina
has
a
package
manager
built
in
and
it
has
this
concept
of
connectors
connectors
are
explicitly
network
systems
and
we
can
see
there's
a
connector.
There
called
W
so
to
slash
Twitter,
so
I'm
going
to
pull
that
and.
B
I'm
going
to
create
a
new
endpoint,
which
is
a
Twitter
implant,
they
don't
get
a
call,
so
this
is
going
to
be
a
Twitter,
weren't
and
I'm
going
to
call
it.
Twitter
and
I
need
to
configure
a
whole
bunch
of
secrets
and
stuff
to
talk
to
that.
So
you
can't
talk
to
Twitter
without
having
some
oath
to
secrets
and
so
forth,
so
rather
than
waste
your
time
typing
them.
I'm
going
to
just
I,
have
a
snippet
of
code
here
and
I'm
going
to
go
and
copy
and
paste
that.
B
That
is
gonna
I'm
gonna
paste
my
secrets
in
here
right
now,
because
you're
all
watching
and
this
is
being
recorded-
I
don't
want
you
to
see
my
my
twitter
worth
keys.
So
I've
got
them
in
a
config
file
and
I'm
going
to
import
ballerina
config,
which
knows
how
to
read
that
and
it
could.
It
would
also
read
it
from
an
environment
variable
if
necessary.
B
C
B
So
the
type
system
is
a
union
type
system,
it's
very
similar
to
Elm
or
Haskell
and
some
of
those,
but
in
this,
so
what
that
means
is
that
I
can
basically
say
the
response
is
either
a
status
or
a
Twitter
error
and
I
can
handle
each
of
those.
In
turn,
now
that's
fine,
but
for
a
quick
demo,
I'm
going
to
treat
and
I'm
gonna
say
basically
I,
don't
I'm
gonna
I
know
this
is
going
to
Twitter
status.
B
Coming
back
now,
it's
saying
that
it
might
be
an
error
there's
a
way
of
dealing
with
apertures
base,
just
to
say
check
check.
If
it's
an
error.
If
it's
an
error,
then
this
is
going
to
give
me
a
response.
Basically,
gonna
tell
that
the
HTTP
server
there's
an
error
and
h2b
servers
going
to
send
back
a
internal
server
error
to
the
client.
C
B
B
So
this
is
kind
of
nice,
so
what
we're
doing
is
we're
getting
some
name
in
the
body
of
the
message
were
untainted:
it
adding
ballerina
Lang
to
it,
tweeting
that
status
and
then
getting
the
response
back
and
responding
back
to
the
client
with
that
new
Jason
that
we've
created.
So
let's
just
build
that.
B
C
B
See
what
happens
excellent?
Well,
it's
come
back
with
a
created
date
and
it's
Twitter
ID,
so
I'm,
pretty
confident
that
this
has
worked.
But
let's
just
go
and
look
at
my
Twitter
feed
see
one
new
tweet
and
there
it
is
so
in
pretty
short
space
of
time.
We've
done
quite
a
lot
of
things.
Let
me
go
back
to
my
presentation
and
we've
done
hello
world.
Also,
the
caller
did
a
get
request
and
we
got
hello
world
back.
Then
we
did
some
annotations
which
allowed
me
to
the
post
of
a
name
and
return
this
hello
name.
B
Then
we
use
a
Twitter
connector
and
we
did
a
post
of
a
status
and
we
tweeted
that
got
the
response
back
and
responded
back
to
the
client.
But
in
fact
we're
really
doing
some.
Some
data
transformation
I
was
actually
taking
that
body
of
the
message
as
a
text
on
tainting
it,
adding
a
hashtag
and
then
turning
that
response
from
Twitter
into
a
different
Jason
to
send
back
to
the
caller.
So
quite
a
lot
of
nice
things
now,
I
said
before
that.
That
era
had
some
different
semantics.
B
One
of
the
really
nice
things
here
is
that
the
semantics
of
this
network
send
is
it's
inherently
async
IO?
What
does
that
mean?
That
means
that
when
I
do
that,
let
me
go
back
to
my
Twitter
thing
when
I
go
and
do
this
Twitter
arrow
tweet.
That
might
take
some
time
now,
if
I
did
that
in
a
normal
in
Java,
say
by
default.
That
would
block
a
thread
while
it's
waiting
for
the
Twitter
to
respond
in
no
J
I
would
use
a
callback,
so
I
basically
say
I.
B
Want
you
to
go
away
and
do
this
and
call
me
back
when
I'm
done
and
then
I
would
have
to
embed
all
this
ongoing
logic
into
my
callback
in
Ballerina.
It
does
both
of
those
things
for
you,
so
this
logic
happens
after
this
thread.
So
this
this
thread
is
not
blocked.
There's
a
worker
which
is
dissociated
from
the
thread,
and
this
syntax
that
comes
after
the
the
Twitter
tweet
is
basically
a
continuation.
So
it
happens
on
a
different
thread,
but
you
don't
have
to
worry
about
that.
B
B
One
of
the
things
that
inspired
us
is
that
whenever
we
kind
of
build
these
systems
for
our
customers
or
for
ourselves,
we
always
end
up
drawing
sequence
diagrams
a
bit
of
UML.
That
I
think
is
most
useful
to
capture
these
code
interactions
and
the
language
of
ballerina
is
is
isomorphic
to
a
sequence
diagram,
and
this
is
where
this
arrow
syntax
came
from,
because
that's
like
an
arrow
in
a
sequence
diagram,
and
if
I
go
look
at
this
little
icon
in
the
corner,
it
says
bothering
a
show
diagram,
I
click
on
that.
B
It's
going
to
show
me
that
sequence
diagram.
Let
me
just
enlarge
that
for
you,
so
you
can
see
this
is
the
sequence
diagram
generated
from
that
code,
so
I
have
the
caller
sending
over
the
body.
I
do
a
bit
of
logic.
It
tweets
that
to
my
Twitter
endpoint
I
get
the
response
back.
I
do
a
bit
more
transformation.
I
created
Jason
and
I
send
that
Jason
back
to
the
caller.
This
is
this
is
really
nice.
B
C
B
You
can
see,
as
I
did,
that
it's
updated
the
sequence
diagram
with
that.
If
aspect.
So
that's
really
nice.
So
we
have
a
language
that
has
a
sort
of
inherently
network
oriented
approach.
It's
based
on
sequence,
diagrams.
It
does
asynchronous
I/o.
It
has
services
and
endpoints
as
first-class
citizens.
It's
it's
really
a
language,
that's
designed
to
build
cloud
native
applications,
but
let's
go
a
step
further
and
actually
show
that
in
practice
and
deploy
this
code
into
kubernetes
and
show
you
that
it
is
really
a
cloud
native
language
in
more
senses
than
that.
C
B
B
So
if
I
now
go
and
kill
this
window
and
clear
that
and
now
I'm
gonna
build
that
again
and
what
it's
done.
Let
me
just
enlarge
that
window.
It's
actually
sorry,
the
the
screens
doesn't
show
very
well
in
vs
code,
but
basically
it's
actually
building
the
docker
container,
the
docker
file
and
it's
building
all
the
llamó
for
kubernetes.
So
it's
doing
all
of
that.
For
me,
just
from
those
simple
annotations-
and
it
now
says,
if
you
want
to
deploy
this
you've-
got
two
choices,
because
it's
actually
not
just
filter
kubernetes
yeah.
B
Well,
it's
also
built
a
home
chart
for
your
app.
So
you
can
either
do
a
cue
cuttle
apply
to
add
this
or
you
can
do
a
home
install.
So
let
me
just
show
you:
let
me
enlarge
this
command
window
a
little
bit
more,
so
you
can
see.
What's
going
on
and
I'm
gonna
do
cou
couple
get
full
now
I
said:
I've
got
kubernetes
running
here,
it's
running
as
part
of
docker.
It's
really
nice
so
makes
it
really
super
easy.
So
I've
got
nothing
running.
I'm
gonna
do
a
cape.
B
Minus
F
and
it's
all
in
the
kubernetes
directory.
Now
let
me
just
tree
that
so
you
can
see
it
has
created,
helm,
charts
and
it's
created
the
conflict
map
deployment
and
service,
yeah
molds,
the
picker
Benitez,
and
it's
created
the
docker
file.
So
it's
done
all
that
for
me
and
now
I
could
do
cube
couple
get
all
again
and
you
can
see
it's
now
running
on
port
three,
one,
eight
four,
nine!
B
B
So
we've
done
some
Twitter
stuff,
I've
done
it
in
kubernetes,
I'm
gonna,
stop
show
you
demo
stuff
now,
because
I
think
that's
probably
enough
for
the
webinar
just
can
talk
through
a
few
other
things
that
you
can
do
so
one
of
the
the
patterns.
That's
very
common
in
building
distributed
systems
is
something
called
a
circuit
breaker.
So,
for
instance,
suppose
I
want
to.
Instead
of
me,
writing
the
status
I
want
to
go
and
grab
us
a
quote
from
Homer
Simpson
and
then
I
want
to
tweet.
B
That
quote
now
suppose
that
Homer
Simpson
quote
service
goes
down.
What
typically
happens
in
a
distributed
system.
Is
that,
though,
these
servers
that
are
that
are
trying
to
call
another
server,
they
retry,
they
expect
failure
and
they
retry.
So
you
you
expect
that
remote
services
might
go
down
and
when
they
do,
you
treat
retry
them.
The
problem
with
that
is
that
if
that
Homer
Simpson
quote
service
goes
down
and
now
I
have
a
whole
cluster
of
servers,
trying
it
they're
already
trying
it
the
minute.
B
It
comes
back
up,
it's
going
to
be
hammered
and
it's
gonna
go
down
again
instantly.
So
the
circuit
breaker
pattern
basically
says
that
if
that
service
goes
down,
I'm
going
to
give
it
time
to
recover
before
sending
requests
to
it
again
and
that's
a
circuit
breaker,
let
me
just
quickly
show
you
what
that
looks
like.
So,
if
I.
C
B
This
is
very
similar
code
to
what
we've
just
seen.
It's
got
the
same
tweeter.
It's
got
the
same
listener
hears
my
Homer
Simpson
quote:
service
and
I
have
a
circuit
breaker
that
basically
says:
I
have
a
rolling
window
of
ten
seconds
and
every
second
I'm
gonna
have
a
bucket
and
if
I
get
any
failures
at
all,
I'm
gonna
give
it
three
seconds
to
back
off
before
coming
back
and
I
gotta
treat
a
one-second
delay
as
being
that
the
service
is
down.
B
So
in
this
model
it's
really
really
easy
and
I
can
show
you
that
the
sequence
diagram
for
that
I'm
basically
gonna,
try
and
get.
That
quote,
because
it's
got
the
circuit
breaker.
It's
going
to
automatically
use
the
error
handling
to
to
tweet
a
a
standard
tweet
if
it's
down
carry
on
and
then
pay
low.
So
this
kind
of
stuff.
Now
you
can
do
this
with
ballerina
with
a
service
mesh.
So
that
would
be
another
way
of
doing
this
and
there's
some
great
guides
on
how
to
get
ballerina
with
ISTE.
B
Oh
and
voice
link
addy
up
on
the
ballerina
website.
But
if
you
just
want
a
circuit
breaker,
you
don't
necessarily
want
to
install
a
whole
service
mesh
to
do
that,
and
so
so
the
circuit
breakers
are
built.
In
another
thing,
that's
really
important
in
a
cloud
native
environment
is
observability,
so
out
of
the
box,
ballerina
supports
open
tracing,
so
you
just
have
to
configure
it
to
point
at
your
Jaeger
or
is
it
kin
install
and
it
will
generate
these
kind
of
charts?
There's
no
coding
required
to
do
that
again
after
the
box.
B
It
it
has
Prometheus
and
graph
on
of
support,
so
it
will
produce
metrics
on
how
many
requests
there
are,
how
many
errors,
many
things
are
in
progress.
All
of
that
kind
of
metrics
will
come
straight
out
of
the
box
and
it
also
works
with
other
observability
services
like
honeycomb
and
who
knows-
and
it's
a
very
good
webinars
out
there
about
that-
and
you
know
it
works
with
LK.
Admittedly,
that's
just
a
question
of
killing
the
logs
in
the
right
place,
but
there's
some
nice
documentation
on
how
to
how
to
work
with
it.
B
Hello,
so
this
is
a
kind
of
hello
world
just
like
you've
seen
it
has
a
docker
config
in
it
this
time,
and
it
says
hello
world
and
that's
the
current
thing.
I'm
gonna
go
hello,
CNC,
yeah
and
I'm
going
to
save
that
and
now
I'll
just
go
back
to
my
terminal
and
I'm
gonna.
Do
a
let's
see
if
I've
got
it
up
in
my
history
there
we
are
I'm,
gonna,
get
add.
B
So
I'm
checking
that
in
to
get
code,
fresh
is
linked
to
my
github
account,
so
that
is
going
to
automatically
fire
off
a
build.
So
if
I
go
back
to
code
fresh,
we
can
go
and
see
that
there's
a
build
now
running
or
depending
so
I'll
show
that
a
second,
let
me
just
show
you
what's
happening
so
I
have
a
kubernetes
cluster
running
in
Google
cloud
platform
and
that's
got
a
service
which
has
got
my.
B
Let
me
go
look
at
the
services
has
got
my
ballerina
code
running
and
if
I
go
click
on
it,
it
says
hello
world,
because
that's
the
old
version
code
fresh
is
going
to
go
through
a
little
build
process.
That's
going
to
clone
that
repository,
build
the
service
test
test
it
build
the
image,
push
the
image
and
deploy
it
all
to
kubernetes
cluster,
and
this
is
all
configured.
Let
me
just
quickly
show
you.
B
This
is
all
configured
off
a
code,
fresh
animal
which
has
those
steps
in
it.
So,
if
I
go
and
keep
gonna
kill
that
ballerina
window,
so
you
can
see
those
steps
that
I
just
showed
you
in
the
code.
Flash
window
are
the
package
it
which
basically
does
following
a
build,
be
test,
run
the
tests
so
buying
a
test,
create
the
image,
push
the
image
and
deploy
to
the
cluster.
So
let's
go
and
see
how
that's
doing
pretty.
Well,
we've
cloned
it
we've
run
the
tests
they're
all
working.
B
Let
me
show
you
so
the
tests
have
run.
Ballerina
has
its
own
built-in
unit
test
system,
which
is
which
is
really
nice,
and
this
is
not
doing
a
local
test.
This
is
doing
a
genuine
Network
test,
so
this
is
doing
starting
up
the
server
and
doing
an
HTTP
call
to
it.
So
it's
a
proper
network
unit
test.
It's
just
building
that
docker
image.
C
B
B
B
Not
know
it's
the
curse
of
a
live
demo.
I
really
come
back
to
that
in
a
minute.
Sorry
about
that
guys.
So,
as
you
can
see,
it
fits
nicely
into
a
continuous
thing.
It
has
built-in
support
for
gr,
PC
and
protobuf.
So
you
just
right
ballerina
code
and
it
generates
the
protobuf
for
you.
It
makes
it
super
easy
to
write
those
kind
of
network
services.
It
has
built-in
support
the
swagger.
B
If
you
know
what
that
is,
that's
a
HTTP
restful
description
language,
you
can
just
say,
give
me
a
swagger
for
this
ballerina
program
and
it
does
that
you
don't
have
to
do
any
annotations.
You
can,
if
you
want,
it,
has
a
full
async
model
as
well.
So
I
said
that
it's
doing
the
async
under
the
covers.
If
you
want
to
do
your
own
async,
then
you
can
basically
there's
futures
and
starts
there's
a
very
powerful
concurrency
model
based
on
workers
and
messages
across
channels.
B
B
As
you
can
see,
a
very
nice
editing
facility
in
in
vs
code
and
also
in
IntelliJ
built-in
unit
testing,
integrations
with
test
arena
and
I
hope
you
like
it.
That's
basically
my
demo,
everything
I
demoed,
is
in
in
set
of
guides
on
ballerina
IO
called
ballerina
by
guide
those
are
the
versions
are
used,
and
so
to
summarize,
you
know
we
have
a
language
head.
That's
really
designed
to
help.
You
write
to
glue
logic
between
micro-services
API
in
SAS
apps
and
a
different
types
of
network
endpoint.
B
It
is
a
general-purpose
language,
but
it's
really
focused
on
this
ability
to
write
these
simple
pieces
of
glue
logic
between
different
Network
endpoints,
to
visualize
them
as
sequence
diagrams,
and
to
be
highly
productive
and
agile
in
that,
in
that
space
and
I
talked
about
a
whole
set
of
capabilities
to
see
ICD
Union
types,
I
didn't
go
into
the
worker
model
and
concurrency
model,
but
it's
very
simple
and
very
powerful.
I
didn't
talk
about
things
like
lambdas
versioning,
which
is
built
in
all
sorts
of
other
capabilities
that
it
has.
It
has,
for
instance,
some
capabilities.
B
Do
long
running,
workflow,
Sando
checkpointing,
there's
the
ability
to
do
stream
processing,
there's
all
sorts
of
nice
stuff
in
there.
So
I
really
encourage
you
to
find
out
more
any
of
you
who
happen
to
be
in
the
UK
and
I
know.
That's
where
a
global
audience
today,
so
I'm
I'm
being
a
bit
parochial
but
I'm,
based
in
the
UK
and
I'm
gonna,
be
talking
at
a
ballerina
day
in
London
on
November
15th.
So
please
sign
up
that's
a
free
registration
and
most
of
all,
I'd
really
love
to
see.
B
You
know
people
here
get
involved,
you
know.
So
it's
an
open
source
project
pull
requests
are
most
welcome.
It's
under
the
apache
license.
There's
a
great
website.
Ballerina
io.
We
were
very
active
on
stackoverflow,
there's
a
slack
channel
where
we're
also
very
active.
So
please
get
involved.
You
know,
there's
multiple
ways
of
contributing.
You
can
help
us
improve
the
syntax
and
the
antics
of
the
language,
that's
still
being
tweaked
or
not
quite
100.
Yet
you
can
write
new
connectors
for
different
end
points.
B
You
can
help
integrate
it
into
different
runtimes,
we'd
love
to
add
a
ever
talked
Cloud
Foundry
plug-in
alongside
the
doctrine
kubernetes.
So
there's
a
whole
bunch
of
things
that
we'd
love
contribution
on,
or
you
can
just
tell
us
what
you
think
and
and
and
get
involved
that
way
and
I
I
want
to.
As
one
of
the
kind
of
questions
people
might
ask,
is
you
know
what
stage
is
this
language
at?
So
we're
not
completely
language
locked
on
the
syntax,
so
we
are
still
doing
the
syntax,
but
it's
pretty
robust.
B
We
do
automated
performance
tests
with
every
release.
We
do
long-running
tests
and-
and
there
are
people
are
using
this
in
production
already.
So
it's
a
funny
sort
of
situation,
we're
way
it's
stable
to
write
code
in,
but
at
some
point
you
might
have
to
port
that
code
over,
but
to
100
when
we,
when
we
finally
lock
the
language
so
I
hope
that's
been
useful
and
I
really
want
to
thank
everyone
for
taking
the
time
and
I
hope.
B
B
B
That's
that's
a
really
interesting
question,
so
the
I
think
the
the
cloud
integration
talk.
It's
like
mill,
soft
and
and
Dell
Boomi
snap
logic
are
a
really
really
good
if
you
are
a
what
they
cost:
citizen
integrator,
so
citizen
integrate
with
someone
who's
trying
to
integrate
their
own
stuff,
you're,
a
business
guy.
You
you
understand
the
business
and
you
want
a
simple
drag-and-drop
approach
and,
as
you
know,
and
I
have
no
problem
with
that.
B
I
think
I
think
that's
really
useful,
but
I
think
if
you're
a
developer,
trying
to
do
that,
integration
that
those
kind
of
drag-and-drop
environments
and
those
which
are
fundamentally
managed
by
a
DSL
in
the
background,
domain-specific
language
are
really
painful.
You
know
I
think
developers
like
real
programming
languages
and,
for
example,
you
know
when
you
come
to
do
one
of
those
things
like
a
string,
manipulation
in
in
one
of
those
toolkits.
B
You
you
end
up.
Actually
the
language
doesn't
just
support.
General-Purpose
stuff,
you
end
up
saying:
okay,
now
I'm
gonna
drop
into
JavaScript
or
I'm
gonna
drop
into
a
different
model.
Sometimes
sometimes
you
need
XPath.
Sometimes
you
need
JSON
path.
So
you
have
all
these
kind
of
constructs
that
help.
You
do
everyday
things,
but
as
soon
as
you
do
that
you're
now
in
two
different
worlds:
you're
in
the
DSL.
That's
that
doing
overall
flow
and
then
you're
in
JavaScript
to
handle
the
your
bit
of
logic
and
and
Ballerina
doesn't
have
that
device
you're.
B
Just
in
in
a
language.
It's
a
it's
a
full
programming
language.
You
get
a
graphical
view,
but
as
a
programmer
you
can
write
code,
but
you
don't
have
to
spend
so
much
of
your
time
worrying
about
connectors
network
handling,
circuit,
breakers,
Jason
transformation
and
so
forth,
because
the
code
understands
those
things
in
unity.
B
A
really
interesting
question,
I
think
I
think
you
know
go-
is
not
designed
with
this
sort
of
tighter
focus.
I
think
this.
This
language
has
been
designed
to
help
you
do
these
kind
of
network
integration
tasks.
Go
is
a
very
general
purpose,
language
with
whether
you
know
there's
designed
to
build
highly
concurrent
system
services,
and
you
can
build
highly
concurrent
system
services
with
this,
and
you
can
build
really
good
Network
programs.
Let's
go
so
you
know
most
languages
are
sort
of.
B
You
know,
there's
that
there's
the
concept
of
true
and
completeness,
you
can
do
pretty
much
anything
with
any
language.
I
think
go,
doesn't
inherently
address
these
network
challenges.
So
in
go
you
you
solve
these.
These
network
problems
by
using
the
concurrency
model
to
say
now,
I
want
to
go
and
handover
my
network
piece
of
code
to
another
go
routine
in
Ballerina
and
that's
implicit.
Every
time
you
call
a
network
service
with
that
arrow
you're,
implicitly
dealing
with
it
asynchronously
with
another
work
with
it
with
a
separate
piece
of
worker
logic.
B
That's
this
under
the
covers
I'm.
What
I
just
said,
there's
not
actually
strictly
accurate,
but
it's
that's
the
intent
of
it.
It's
handling
it
for
you,
the
async
I/o,
without
you
having
to
worry
about
it
and
I
I.
Think
the
other
thing
that
that
ballerina
has
has
I
have
to
say
I,
think
the
type
system
is
is
slightly
more
beautiful
than
goes
type
system.
But
that's
you
know,
your
mileage
may
vary
a
bit.
That's
I
think
a
personal
thing,
but
I
do
think
that
it's
a
slightly
simpler
language
to
learn.
B
I
I
think
it's
I
I
found
it
easier
to
learn
ballerina
than
to
learn
go
so
you
know,
and
again
that's
personal,
but
I
think
it
has
a
sweet
spot
when
it
comes
to
building
these
network
services.
That
is
more
optimized.
For
that
than
go
is
and
I
know,
go
is
more
optimized
for
some
other
things
and
if
I,
if
I,
wanted
to
be
slightly
snarky
and
I'm
only
joking
here,
so
please
don't
take
offense
I!
Think
the
other
thing.
It
says
that
we
built
our
package
management
in
from
day
one.
B
A
great
question:
yes,
it
is,
and
there's
already
support
for
ballerina
functions
in
cublas
and
in
open,
whisk
and
I
know
that
that
the
ballerina
team
and
and
some
other
teams
are
working
on
getting
serverless
support
into
other
frameworks
as
well.
But
those
are
the
two
I
know
about
already
that
already
are
shipping
ballerina
supports
and
that's
cublas
and
open
whisk.
B
So
certainly
I
mean
I
mean
lots
of
cloud
work.
Clothes
have,
you
know
very
complex
logic.
That
is,
that
is
not
just
talking
to
other
network
services.
Now
you
know
we
have
a
object
model.
So
ballerina
has
the
concept
of
objects.
It's
not
it's
not
a
it's
a
simpler
model
and
say
Java
or
C
sharp.
It
doesn't
have
all
the
inheritance
and
stuff.
But
you
know
if
you
wanted
to
model
out
a
highly
complex
set
of
business
domain
logic,
I,
wouldn't
use
ballerina
I
think
that
that's
not
its
purpose.
B
Now
other
people
might
I'd
say
you
know
you
can
do
that
and
you
certainly
can,
but
that's
not
where
I
see
the
sweet
spot
for
bothering
I
see
the
sweet
spot
in
in
writing
this
this
logic
that
that
orchestrates
and
and
composes
between
other
services
that
that
have
their
heavy
lifting
on
the
business
logic.
Now
that
doesn't
mean
you
know,
I
think
there
are
simpler
ways
of
writing
business
logic,
but
I
wouldn't
write
a
core
banking
application
in
Ballerina
today,
but
I.