►
From YouTube: CNCF Serverless WG Workflow Meeting - 2018-07-17
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
A
So,
let's
so
that
goes
through
this
agenda,
I
think
first
I
think
that
they
were
going
to
do
the
presentation
and
then
we
are
going
to
go
through
the
review
comments.
I
see
that
now
here
are
some
video
comments
which
we
can
discuss.
Okay,
so
let's
first
start
with
the
presentation:
I'm
going
to
start
first
to
talk
about
function
graph.
Let's
share
my
screen:
okay,
here's
a
meeting
minutes,
so
maybe
someone
can
help
right.
I'm
gonna
write
the
meeting
minute,
but
if
someone
else
can
help
right
here,
oh
good,
let
me.
B
A
So
in
function
model,
so
it's
like
is
this
function.
Work
flow
is
naturally
mouth
as
a
state
machine.
There
are
three
elements
in
the
function
graph,
so
why
is
the
list
of
event
triggers?
That's
like
the
crowd.
Events
reason
could
be
storage,
even
HTTP
event
or
any
other
media
stream.
Even
you
know,
database
access,
event,
email
event,
code,
repo
update
any
event.
Okay.
This
is
just
like
some
example
and
then,
besides
event
trigger,
there
will
be
some
list
of
states,
so
we
have
been
no
five
on
States
banker
event.
A
State
operation,
states
which
state
the
late
state
and
state
yeah
I'm,
going
to
sue
them
later,
I
mean
in
more
detail
in
later
slides,
and
then
there
are
also
functions
or
even
protections
or
social
is
the
state
resemble
in
the
event
state?
If
my
event
comes,
it's
going
to
trigger
some
function
and
this
function,
will
you
know
in
the
function?
You
know
it
could.
Like
some
primitive
say,
you
know
it's
parallel
execution
of
these
functions
or
a
sequential
exclusion
is
from
cheap
execution,
and
then
there
will
be
could
be
retry
mechanism
if
the
function
fails.
A
What's
a
retry
mechanism
and
they
also
like
some
information
passing
from
them
from
you
know
between
the
functions
of
from
the
previous
function
to
the
next
function.
So
these
are
the
three
key
elements
of
the.
What
role
so
on
the
right
side
is
just
a
diagram
of
that.
You
know
that
workflow
just
example
diagram.
So
let's
go
to
this
versus
see
the
list
of
states.
We
have
you
know.
As
mentioned
before,
we
have
five
states
event.
States
is
used
to
wait
for
events
from
event
sources.
A
So
this
event
source
could
be
an
event
source
as
mentioned
before,
and
then
you
know
when
that
event
comes
it's
going
to
invoke
one
or
more
functions
to
run
either
sequence
or
in
parallel,
so
it
could
be.
The
event
could
be
multiple,
but
not
just
one
event
could
be
and
or
relationship
of
this
event
so
could
be
say
you
know
when
event
one
counts
or
event
two
comes,
then
you
know
this
function
need
to
be
executed
or
it
could
be
you're
on
the
USA
when
both
event
cups
and
that
functional
are
specific
changes,
sugar.
A
So
that's
the
event
state
and
then
this
operation
state.
So
operate
the
difference
between
event.
State
operation
state
is
that
you
know
heuristic
does
not
need
to
be
triggered
by
any
effect.
So
when
it
goes
to
that
step,
then
it
just
automatically
one
or
more
functions
were
wrong,
either
in
sequence
or
in
parallel,
but
without
waiting
for
any
event,
the
other
part
are
the
same
tool.
Events,
the
only
difference
is,
is
not
triggered.
Those
functions
are
not
triggered
by
any
event
and
then
there's
a
switch
state.
This
state
permits
the
transition
to
other
states.
A
You
know,
based
on
different
conditions,
for
example,
could
be
you
know
the
previous
steps
function.
Execution
result,
you
know
different
function,
execution
result
in
the
previous
step,
previous
step
or
previous
date
or
trigger.
You
know
a
brunch
in
two
different
next
dates
or
could
be.
You
know
the
other,
some
other
condition
too,
and
then
it's
at
the
race
day.
This
is
just
you
know,
causes
the
work,
prosecution
to
delay
for
a
specific
duration
or
until
a
specific
time
or
date.
This
is
very
simple
this
day,
race,
day
and
state.
A
This
determines
a
workflow
with
some
either
failure
or
success
status.
So
when
the
wardrobe
ends
is
going
to
go
to
the
end
state,
it
could
end
with
successful
execution
of
the
workflow,
always
a
failure
execution
of
the
workflow.
So
these
are
the
states
and
then
these
are
the
event
children
so
event
triggers.
We
have
three
say
parameters:
Y
is
the
event
source.
It
could
be.
The
crowd
you
know
could
be
any
event
source.
A
This
is
same
as
a
cloudy
event
source
and
there
will
be
an
event
ID
and
then
will
be
the
filter
apply
to
the
to
the
crowd
event
to
get
the
required
information,
which
you
know
will
be
passed
to
the
next
us,
which
will
be
part,
would
be
passed
to
the
function.
Okay,
so
this
is
filter
on
the
payload
or
on
the
could
young
pillows
or
any
other.
You
know
metadata
information
on
the
crowd
events
and
then,
after
the
filter,
the
information
will
be
passed
to
the
function
or
could
be
passed
to
the
next
state.
A
So
the
trigger
name
is
the
name
of
the
events,
and
this
main
will
be
used
by
the
other
expression
in
the
event
state.
So
in
the
event
state
and
when
we
say
okay,
even
one
Orkut
event,
for
example
like
motion
event,
so
that's
the
event
name
that
even
name
is
defined
in
here.
This
is
a
even
a
trigger
name
and
then
the
other
information
we
decide
in
the
event
itself.
A
A
Anyway,
the
date
it
could
be
both
okay,
so
a
function.
Okay,
so
event,
so
now
I'm
going
to
go
through
the
it
easy
man
so
for
the
event
state
we're
going
to
the
you
know
this
dates
name,
there
will
be
a
time
so
for
this
type,
even
state,
the
type
will
be
event.
If
it's
a
operational
state,
the
type
will
be.
Let
me
go
to
the
next
one.
So
then
the
type
you
see
this
this
parameter,
this
type
will
be
operation
and
then
for
the
switch
state.
The
type
will
be
no,
not
this
one.
A
The
type
will
be
switch.
So
let
me
go
back
so
just
this
type
just
may
say
what
kind
of
state
it
is.
We
have
five
different
types
of
state
and
then
the
start
putting
mean
that
with
especially
that
this
is
a
starter
state
or
is
a
intermediate
state.
So
if
it's
a
start
state
this
will
be
set
to
true,
so
the
workflow
could
start
with
with
the
Union
state
or
could
start
with
the
operation
state.
It
could
be
onion
except
the
end
state.
A
It
could
start
with
a
new
state
and
then
so
for
the
event
state.
A
key
part
is
that
you
know,
because
this
event
states
satisfied
what
you
when
triggers,
what
function
at
that
specific
step.
So
we
have,
we
were
defined,
what
events,
what
you
got
that
function,
so
here
there's
a
given
expression.
It's
a
boolean
expression
of
the
events
and
then
there's
a
action
mode
which
defines
the
function
basically
is
a
function
mode
is
a
synchronous
or
asynchronous
the
function.
So
if
there
are
multiple
functions,
we
can
see
these
actions
means
the
functions.
A
The
function
you
know
there
will
be,
it
could
be
array
of
functions.
So,
if
other
like
more
than
one
functions,
are
they
going
to
execute
it
in
sequence
or
in
parallel?
This
is
defined
in
the
action
mode
and
then,
of
course,
will
be
the
next
state
which
means,
after
this
event,
state
function.
Execution
completes
what
is
the
next
state
to
transition
to
okay,
this
is
a
human
state
and
then
you
know
go
to
the
next
operations
day.
A
So
the
only
difference
between
this
and
the
event
state
is
that
it
doesn't
need
to
even
trigger
so
there's
no
definition
of
the
events
of
the
event
trigger
here's,
a
typist
operation
start
again.
It
could
be
a
it
could
be
the
start
state.
So
if
he's
truly
is
a
start
state,
otherwise
it's
not
the
start
state
and
the
is
same
thing
as
before:
there's
action
mode,
which
is
synchronous,
asynchronous
and
then
the
actions
is
a
sequence
of
running
as
a
list
of
functions
that
would
be.
A
That
would
be
that
will
run
in
this
state
and
then
will
be
in
the
next
state,
and
here
is
remember
in
the
previous
two
state
with
this
event
state
or
action
state.
We
have
this
action
definition.
So
this
is
a
function
definition
you
know,
there's
a
action
mode,
which
is
synchronous
asynchronous,
which
defines
whether
these
two
or
more
function
will
execute
in
sequence,
way
in
synchronous
or
asynchronous
mode,
and
then
this
action
definition
defines
the
detail
actions.
A
So
here
is
the
action
emanation
we
have
the
function,
name,
that's
based.
In
fact,
this
is
again
as
a
action.
Different
could
be
array
of
action.
Definition
array
of
actions,
so
each
action
was
specify.
What's
the
function
name,
what
is
a
timeout
value
and
then
what
is
the
retry
mechanism,
like
you
know
when
you
match
so
when
the
function
returns?
Something
so
mentioned,
result
value,
which
is
you
know
when
the
functions
result
you
match
that
result
and
then
what
is
entry?
A
So
yeah,
that's
that's
about
it
and
then
the
switch
state
is
right.
You
know
it's
like
a
switch,
you
know,
so
you
match
again
time
to
switch
pudding.
This
could
be
the
start
state
and
then
Tracy's,
like
you
know
what
you
do.
So
that's
where
specify
so,
for
example,
we
got
this
okay,
this
tries
to
depend
on
the
different,
the
event,
event,
data
or
event
info
or
the
function
results
information.
So
then
we
need
to
apply
a
filter.
A
This
apart
is
basically
like
upon
payload
Pass,
say
which
field
will
be
used
as
a
match
to
this
value.
Here,
there's
a
value
because
you
know,
for
example,
if
this
event
right,
it
has
a
lot
of
information
that
even
payload
has
a
lot
of
information
or
there
many
multiple
event
makes
a
deadly
information
so
which
field
we
are
going
to
use
to
do
the
to
do
the
matching.
A
So
this
path
specify
that
that
that
part
and
then
the
value
specify
whether
you're
right,
you
know
what
were
you
two
to
match,
so
it
matched
so
this
trace
is
is
a
kind
of
record
or
at
least
array
right.
So
therefore,
you
match
different
module
you're
going
to
do.
This
is
a
comparison
operator.
For
example,
you
say
this
value
is
equal
to
this
value
or
larger
than
this
value
or
smaller
than
this
value,
and
then
you
match
different
Vario
you're
going
to
switch
to
different
next
state.
A
That's
about
it!
It's
just!
You
know
this
just
way
to
model
the
workflow,
so
different
types
of
workflows
can
be
modeled
using
all
these.
These
events
come
back
to
the
original
uses.
You
know
different
space
and
then
events.
So
one
point
which
I
you
know:
I
haven't
got
time
to
add
it.
It
is
about
the
correlation,
for
example,
in
the
so
here
there
are
multiple
events
right.
So
when
this
event
comes
how
we
correlate,
you
know
this
event
1.
This
is
even
one
instance,
and
this
event
two
instance,
or
go
to
the
same
workflow
instance.
A
So
we
need
a
correlation
and
that
can
be
defined
at
the
very
at
the
beginning
of
the
workflow.
So
I
didn't
you
don't
have
time
to
put
in
this
right
here,
but
if
you
go
to
the
I
can
put
that
in
later.
A
D
This
is
Rachel,
it
seems
like
it's
a
pretty
thought-out
way
of
like
what
you
need.
It's
like
a
great
it's
a
great
statement
of
like
what
we
need
to
be
able
to
support,
and
this
seems
like
a
very
like
it's
a
specific
use
case,
but
it's
very
generalizable,
like
everyone
will
need
to
do
these
kinds
of
things.
So
I
appreciate
you
like
walking
us
through
those
look.
A
Okay,
I
think
you
know,
probably
in
though
you
can
yeah
you
can
you
know
I'm
gonna,
do
this
right
in
some
I
mean
some
place
and
then
you
can
go
through
it
again
and
then
you
know,
if
I
have
any
comments
I'm
going
to
this
inside
the
document
too,
so
you
can
feel
free
to
post
it.
We
have
comes
through
I
have
gone
through
this.
You
know
we
have
gone
through
this
on
multiple
times,
I
think
a
noise
generic
enough
to
support
this
or
these
functionality.
Of
course,
you
know
they're
still
quite
some.
A
B
E
Thanks
so
hi
I'm,
with
IBM
Research
and
I'm,
an
open
news,
contributor
and
I'd
like
to
tell
you
yes
a
little
bit
about
what
we're
doing
with,
say,
workflow
and
open
whisk.
As
you
notice,
we
call
them
composition
that
workflows
and
you
see
there
are
some
some
differences
that
will
be
clear
after
this
talk,
so
because
it's
a
bit
different
I
before
telling
you
what
we
do,
I'd
like
to
tell
us
a
little
bit
about
why
we
do
things
we
do
them,
and
so
here's
a
list
of
goals
or
things
we're
trying
to
accomplish.
E
So,
of
course,
we're
trying
to
build
wealth
flows
or
compositions
of
functions,
and
there
are
several
important
things
in
our
view
when
we
do
that,
you
know,
starting
from
you
know,
maybe
non-controversial
ones
to
more
controversial
ones.
So
if
you're
swinging
want
things
to
be
polyglot,
so
we
want
functions
to
be
expressed
in
you
know
many
different
programming
languages.
We
want
compositions
as
well
to
be
to
make
it
possible
to
express
in
many
different
programming
languages.
E
We
care
a
lot
about
the
costs,
the
billing,
so
what
that
means
is
we
want
to
have
an
architecture
want
to
have
a
system
and
a
programming
model
where
the
cost
of
the
composition
is
pretty
much
the
cost
of
the
thinking
composed.
Of
course,
you
know
you're
making
some
choices,
you're,
making
some
decisions,
but
these
are
typically
very,
very,
very
cheap
computations,
so
that
should
be
reflected
by
the
fact
that
we
can
run
composition
pretty
much
at
the
cost
of
the
components.
E
One
thing
that's
really
important
to
us
is
what
I
call
substitution
you
can
think
of
that
as
meaning
that
functions
and
compositions
should
be
totally
interchangeable.
So,
for
instance,
if
I
have
a
client
application
that
calls
into
a
function
if
I
later
decide
that
this
function
is
just
too
simple
and
I
want
to
replace
it
by
a
composition.
I
can
do
that
in
my
library,
the
client
doesn't
have
to
change
from
the
point
of
view
of
the
client.
This
is
exact
same
API
to
call
a
function
or
a
composition,
in
particular
in
open
ways.
E
We
can
call
functions
in
a
synchronous
manner
in
a
blocking
manner
where
we
say
Co
the
function
and
wait
for
the
result
and
get
the
results,
so
that
should
also
work
with
compositions.
So
that
means,
for
instance,
that
doing
just
even
driven
asynchronous
composition
doesn't
quite
get
it
for
us
another.
You
know
something
related
to
that
is
as
a
function
runs
in
a
system.
It
doesn't
have
to
know
whether
it's
just
called
by
a
client
or
call
by
an
enclosing
composition.
Nothing
changes
from
the
point
of
your
function
may
be.
E
The
function
might
want
to
know-
and
you
know
do
some
things
according
to
that,
but
it
doesn't
have
to
know
in
principle.
It
just
works
now.
The
the
big
thing
about
our
approach
is
that
we
very
much
believe
in
structured
programming.
We
think
that
you
know
in
the
sense
that
you
know
describing
for
flows
or
composition
as
graphs,
as
you
know,
vertices
and
edges
it's
great
for
discussing
them,
it's
great
for
displaying
them
it's
great
for
documenting
them,
but
necessarily
great
for
actually
programming,
complex
behaviors.
E
In
the
same
way,
we
think
that
you
know
ya
know
maybe
a
great
configuration
language,
but
it's
not
a
programming
language.
So
what
we
want
to
do
is
to
get
something
much
closer
to
the
traditional
programming
experience
of
composing
functions
in
a
you
know,
outside
of
the
cloud
in
the
traditional
environment.
That
means
we
want
to
do
things
like
sequences
conditional
loops.
We
want
to
be
able
to
have
nested
compositions
compositions
that
calls
into
composition
that
goes
into
composition.
E
E
Why
we're
very
opinionated
about
you
know
the
way
we
think
is
the
best
way
to
express
compositions.
We
think
the
runtime
on
the
other
end
should
not
be
open
unity
at
all.
It
should
be
completely
open
minded.
It
should,
you
know,
contain
as
little
as
possible
of
the
choices
we
have
in
program.
All
it
should
be
as
flexible
as
possible,
so
it
should
support.
E
You
know,
running
compositions,
but
you
know
in
a
very,
very
very
frogging
model
agnostic
manner
and
I'll
show
you
that
in
a
few
slides
before
I,
go
I
also
like
to
to
add
two
things
here:
important
again,
not
not
going
to
talk
much
about
it
because
we're
working
on
it.
But
it's
it's
really
in
the
back
of
our
mind
and
really
dictates
some
of
the
decisions
we've
made
already
the
first
one
is,
you
know
we
don't
think
the
end
goal
is
to
actually
compose
function.
We
believe
the
end
goal
is
to
compose
cloud
services.
E
Whatever
databases
you
know,
AI
services,
etc,
etc,
and,
of
course
functions
are
the
place
there,
because
they
they
can
be
great
for
bridging
gaps
between
services,
but
at
the
end
of
the
day,
the
the
workflow,
the
composition
is
a
few
functions
and
lots
of
other
things,
and
this
is
what
we
eventually
want
to
support.
The
last
thing
is,
we
believe:
evens
are
really
really
important,
whether
it's
correlation
or
streaming
and
and
and
their
I
think
it's
been
discussed
quite
a
bit
in
in
this
poll
already
or
in
previous
polls.
E
The
tricky
question
is,
as
we
try
to
make
things
as
we
try
to
express
more
things.
We
also
make
things
more
complex
and
it's
hard
to
know
exactly
where
to
start,
and
this
is
something
we're
working
on
okay.
So
if
we
have
so,
as
I
said
before,
we
want
to
start
with
a
pretty
high
level
language
and
go
down
to
pretty
simple
runtime
infrastructure.
You
can
think
of
it
as
a
RISC
processer,
and
so
how
do
we
do
that?
Well,
you
know
how
how
we
traditionally
do
that
we
essentially
start
with
higher-level
code.
E
We
do
something
that
akin
to
a
compiler,
we
compile
this
to
an
intermediate
representation.
This
is
what
we
run
right.
So
that
means
there
are
two
components
to
what
we've
done.
Well,
so
far
is
no
J's
library
which
used
to
program
compositions.
We
also
have
the
Python
library,
but
it's
not
open
source
yet
and
I'll
show
you
the
no
J
J's
library
in
the
next
slides
and
the
second
one
is
an
extension
to
the
open
with
which
runtime
that
essentially
does
two
things.
E
The
first
one
is,
it
knows
how
to
build
dynamic
change,
the
value
of
functions
right.
We
had
sequence
action
in
open
with
before,
but
you
had
to
define
the
sequence
beforehand,
so
here's
the
key
difference
is
that
the
way
we
as
you
run,
things
you
can
decide
what
to
run
next
and
what
to
annex
and
where
to
go
next
and
when
to
stop.
The
second
thing
is
that
we
also
believe
that
stage
is
important
and
the
runtime
has
to
do
some
state
management
at
least
a
little
bit
early.
E
E
The
first
one
is
language:
ID,
it
detects
the
you
know,
it
tries
to
guess
the
language
of
a
fragment
of
text
and
then
there's
a
translator
function
that
translate
from
a
given
input
language
to
a
given
an
output
language,
and,
as
you
can
see,
this
composition
is
start
mixing
things.
It
has
two
things
in
particular
here.
E
What
you
see
on
the
right
is
something
or
tooling
can
build
a
graphical
representation
of
this
composition,
but
that
can
be
used
for
debugging
monitoring,
etc,
etc.
But
Brown
truce
is
the
code
on
the
left.
This
is
what
you
write.
This
is
where
to
version
control.
This
is
what
you
you
know
edit
in
your
editor.
So
we
have
a
bunch
of
constructs
like
that.
There's
a
longer
list,
but
here
is
the
really
basic
stuff.
Essentially
you
can
have
functions.
You
can
have
sequences.
You
can
have
conditional.
You
can
have
a
loo,
try-catch
kind
of
things.
E
You
can
declare
variables,
you
know
and
other
things
and
parallel
ease
I'd.
You
know
it's
totally
fine
in
these
kind
of
things.
So
yes,
so
that's
pretty
much.
What
I
want
to
tell
you
about
the
program
language
you've
seen
the
the
example
before
and
again.
If
you
look
at
this
slide,
you
can
it's
pretty
clear
that
you
can
do
the
same
thing
in
any
kind
of
programming
language.
The
inline
function.
Syntax
will
change
from
one
language
to
another,
but
essentially
everything
else
is
going
to
be
the
same.
E
So
one
thing
I'd
like
to
see
so
the
way
this
works.
This
is
an
extension
of
the
notion
of
data
flowing
sequences,
so
in
principle,
when
you
have
one
function
executes
after
another
function,
that
means
the
output
of
the
previous
functions
becomes
the
input
of
the
next
function.
That's
that's
the
basic
flow,
but
on
top
of
that
there
is
a
notion
of
state
in
this
composition
right
which
is
composed
of
a
few
things.
The
first
one
is
where
you
are
in
the
composition.
E
Think
of
it
as
a
program
counter
right
or
you
know,
if
you
think,
of
finite
state
machines.
This
would
be
the
actual
stage
you
are
at
in
the
composition,
but
there's
more
than
that,
because
we're
doing
structure
programs.
So
we
have
things
like
registered
exception
handler.
We
have
things
like
variable
declaration,
and
so
these
need
to
be
carried
through
by
our
runtime
implementation.
Additionally,
the
user
can
even
add
some
notion
of
state
that
could
be
added
there
so,
for
instance,
a
callback
to
and
look
at
the
very
end
of
the
execution
of
the
composition.
E
So
we
can
support
this
kind
of
things.
So
the
what
really
key
about
this
state
is
that
what
what
really
needs
to
be
managed
is
the
state
ID
and
the
state
can
be
either
inside
the
runtime
outside
the
runtime
doesn't
matter
what
we
believe
is
the
right
thing
to
do.
If
server
less
is
to
keep
State
inside
the
runtime.
If
it's
small
in
us
right,
if
we
can
manage
it
for
cheap
and
if
you
really
start
having
a
lot
of
state,
then
you
have
to
the
user
has
to
help
you
have
to
provide.
E
You
know,
storage
solution
for
you
for
you
for
your
state
and
then
we're
only
going
to
manage
the
the
keys
to
your
stage.
Okay.
So
how
is
this
implemented?
This
is
implemented
using
a
mechanism
called
conductor,
action,
which
is
the
extensions
we
made
to
the
open,
which
runtime
and
essentially
it's
the
idea
that
a
function
I
mean
again
in
open,
whistle
functions,
actions
but
same
thing.
E
And
when
this
next
type
of
the
composition
is
done,
we
should
go
back
to
the
conductor
action
which
you
can
think
of
the
scheduler
in
all
this
and
then
re-involved
the
scheduler,
with
the
combination
of
what
was
obtained
from
executing
the
component
action,
the
result
and
the
state
that
needed
to
be
preserved,
while
the
action
was
running
right.
So
at
the
bottom,
you
have
a
handwritten
conductor
action.
E
So
we're
not
encouraging
you
to
do
this,
but
you
can
write
conductor,
actions
by
hand,
it's
a
kind
of
a
finite
state
machine
and
what
it
essentially
does
it's
a.
It
builds
a
sequence
with
two
steps
in
the
first
one
we
call
a
function
called
triple
and
the
second
one
we
call
the
function
all
increments,
and
if
you
look
at
the
you
know
what
what
that
means
at
runtime.
That
means
we
start
running
this
conductor
action.
This
scheduler
it
returns
that
we
should
run
triple
first,
so
triples
run.
E
Then
it's
being
written
books
now
it's
at
state
one.
So
that
means
it
decides
that
the
next
step
is
increment
will
run
increments,
then
returns,
and
then
there
is
no
more
action
to
run.
So
this
is
the
end
of
the
you
see
the
end
of
the
execution
reach
the
end
of
the
pipeline,
so
putting
all
of
this
together.
What
that
means
is
we
have
a
library
that
generates
a
JSON
representation
for
the
composition,
so
it's
not
a
finite
state
machine.
E
It's
something
and
I'll
show
you
an
example
in
the
next
slide
is
something
much
closer
to
the
end,
abstract
syntax
race
or
something
very
close
to
what
was
the
syntax
of
the
composition
in
the
first
place,
then
what
we
do
is
we
take
this
JSON
composition.
We
combine
it
with
a
piece
of
code
that
is
essentially
a
scheduler
that
is
going
to
be
body
of
the
action.
It's
the
same
for
all
of
our
composition.
E
It
doesn't
change
only
the
Jason
changes
and
that
this
produces
a
conductor
action,
and
this
is
the
thing
that
the
runtime
system
executes
and
the
way
this
is
executed.
If
you,
if
you,
if
you
again
want
to
know
the
details
that
first
each
translate
these
are
taxed
and
tax
rates
to
something
like
a
finite
state
machine,
and
then
it
interprets
the
finite
state
machine.
But
one
big
difference
with
all
of
the
things
that
we
discussed
so
far
is
that
this
finite
state
machine
is
really
an
internal
representation
of
the
runtime
system.
E
It
can
change
and
it's
definitely
not
there-
the
representation
that
typically,
you
user
programs
with
to
describe
a
composition.
So
you
know
this
is
the
JSON,
so
maybe
at
that
level
it
doesn't
look
that
different.
But
you
can
see
here.
This
is
adjacent
for
the
example
code
I
had
before
it
has.
First,
you
know
the
the
root
node
is
a
try.
Cat
is
a
type
try.
It
has
a
body
and
handler
the
body
itself
is
a
sequence
which
has
which
has
a
few
components.
These
components
is
an
array
of
things.
E
Some
of
them
are
named
action.
Some
of
them
are
inline
functions,
etcetera,
etcetera,
so
that's
about
it
and
just
going
back
to
the
goals.
So
just
a
couple
comments
here,
I've
been
missed.
The
last
the
previous
two
calls
and
I
hope
I'll
be
able
to
join
more
of
these
goals,
but
I
listened
to
the
recordings
and
I
understand
from
Kathy
that
the
goal
of
the
workgroup
is
to
primarily
try
to
define
the
user
facing
representation.
You
know
what
what
the
user,
how
is
the
user
going
to
program
a
workflow
and
I
feel?
E
Maybe
that's
a
bit
premature
I
would
be.
You
know
like
if
I
think
my
view,
what
the
cloud
even
specification
is
really
is
much
more
bottom-up.
It's
trying
to
tackle
and
decide
the
kind
infrastructure
we
can
have
been
common
in
a
runtime
systems
so
that
they
can
collaborate
and
work
together
much
more
effectively.
So
the
reason
I
think
is
a
bit
more
immature
is
because
I
think
there
are
a
lot
of
a
lot
of
options,
a
lot
of
different
ways
to
do
this,
workflows
and
I'm,
not
sure
we
have.
E
You
know
we
have,
we
know
already,
which
what
are
the
good
ones,
the
better
ones
and,
on
the
other
end
I
think
from
the
runtimes
perspective,
we
start
to
understand
kind
of
additions.
We
need
to
make
to
make
it
possible
to
just
run
any
kind
of
oil
for
any
kind
of
program
walls,
whether
you
like
finance,
the
admissions
you
know
like
structured
programming
like
declarative
programming,
I,
think
we
should
be
able
to
agree
on
some
of
the
key
components
of
the
runtime
system.
We
need
to
support
that.
C
E
Having
said
that,
the
world
cookies
doing
to
do
the
right
thing,
which
is
to
look
at
use
cases
right
and
so
so
to
understand
exactly
how
what
are
the
primitive
capabilities
that
we
need.
So,
for
instance,
again,
as
I
said
in
this
presentation,
I
didn't
really
talk
about
parallelism,
currency
or
all
very
much
about
even
so
I
think
these
are
key
things
to
understand
and
the
way
to
understand
them
is
to
go
through.
E
You
know
what
are
the
use
cases
and
you
know
using
finite
state
machine,
for
that
makes
perfect
sense,
but
I
think
then
we
we
should,
rather
than
maybe
shooting
for
a
holistic
definition.
What
are
all
the
holder
states
we
can
have
in
a
finite
state
machines.
Maybe
it
should
be
more
of
what
are
the
different
kind
of
building
blocks
like
we
need
fork?
Maybe
we
need
join,
we
need.
E
You
know
I
really
like
to
think
of
this
as
defining
the
RISC
processer
for
the
cloud
where
we
define
the
minimal
instruction
sets
and
I
feel
like
the
may
be.
The
approach
of
defining
this
finite
state
machine
is
is
he's
trying
to
do
at
the
same
time
understanding
what
what
the
backend
infrastructure
has
to
be
when
it's
the
what
the
primitive
or
the
risk
infrastructure
is,
but
at
the
same
time
it's
also
trying
to
be
the
user
facing
the
user
facing
program
model.
I,
think
I
think
I
mean
in
my
experience.
E
It
makes
a
lot
of
sense
to
not
confuse
user
facing
program
all
and
the
system
representation
of
this.
You
know
the
system
abstraction
because,
because
you
know
they,
yes,
at
the
end
of
the
day,
one
is
supposed
to
be
able
to
execute
everything,
but
they
tend
to
they
very
different
balls
right.
One
is
to
the
goal
of
the
user.
Facing
one
is
to
be
user
friendly
is
to
be
easy
to
understand,
easy
to
refactor
etcetera,
lots,
lots
of
different
things.
The
goal
of
the
system
level
one
is
to
be
minimal,
in
particular,.
A
So
I
think
you
know
it's
important,
separate
I
agree:
it's
important
separator
the
specification
of
the
workflow
with
you
know
how
back-end
is
going
to
implement
it
to
support
that
workflow.
I.
Think
I
agree
with
your
point
on
that.
So
that's
why
you
know
how
you
know
the
service
problem
you
know,
should
continue
or
should
you
know,
do
the
runtime
I
think
you
know
easy
for
me
provide
a
way
for
the
user,
its
desired
application
workflow.
So
that's
why
you
know:
let's
go
to
this
workflow
spec
right.
A
We
have
cases,
you
know
on
investor
meeting
and
so
all
these
use
cases
I
think
you
know
using
this.
Actually
we
look
at
this
use
cases
right
from
users,
point
of
view
kind
of
like
a
statement
based
workflow,
so
the
user
doesn't
need
to
know
the
detail
of
you
know
the
wrong
time
or
you
know
the
detail
of.
You
know
how
you
are
going
to
run
the
you
know
to
schedule
the
resources
for
the
function,
the
user.
Ultimately
just
say
you
know
what
the
user
would
like
to
the
user
needs
to
pass.
A
A
pass,
you
know,
is
desired.
Application
on
specification
to
perform
say:
okay
at
this
time,
you
know
what
event
check
on
my
function
or
maybe
there's
no
event
trigger
the
function.
That
function
just
got
wrong
and
I
know
with
the
is
going
to
branch
out
or
what
so
I
think
that
actually
from
users
perspective
as
they
like,
representation
of
of
the
application
is
innate
than
you
know,
reporting
very
complicated,
I
understand.
E
And
I
think
it
makes
sense,
but
I
think
it's
also
very
opinionated.
We
very
opinionated
view
of
how
to
program
so
in
my
experience,
for
instance,
finite
state
machines
and
things
very
directly
inspired
for
fine
from
finite
state
machines
are
very
familiar
to
a
hardware.
Programmers
are
web
designers
and
they
use
that
a
lot
they
like
it.
A
lot
I
think
it's
much
less.
The
case,
for
you
know
application
traditional
approach
and
application.
Programmers.
B
E
When
I
say
finite,
state
machine
I'll
also
mean
something
vaguely.
You
know
that
resembles
the
finite
state
machines,
yes,
but
I
think,
for
instance,
some
of
the
questions
there.
If
you,
if
you
look
at
financing
machines,
in
particular
the
people
that
do
you
know,
graphical
representation
called
design
languages
for
finite
state
machines,
they
often
fail
to
address
the
problem
of
hierarchical
composition,
which
is
how
you
get
you
know
in
finite
state.
Oh
you
build
larger.
You
know
automata
finite
state
machine
from
smaller
ones.
What's
the
what's
the
what's
the
semantics
for
composing
them
in
particular?
E
What's
the
what's
the
error
semantics
when
you
start
composing
these
things,
how
do
you?
What
does
it
mean
to
abort?
One
of
these
things
I
think
that
that's
that's.
Take
machines
make
a
lot
of
sense.
You
know
as
long
as
they
fit
on
your
screen
and-
and
we
start
sizing
complexity
that
goes
beyond
that.
They
become
much
much
harder
too
many
plates.
E
No
I
sure
so
so
then
then
my
then
my
take
is
well
when
you
build
what
I'm
trying
to
say
here
is
sure.
Maybe
we
can
get
to
finite
state
machine
specifications
that
that
that
does
everything
right
that
does
that
covers
all
the
bases
we
want
to
cover,
but
then
I
think
in
that
case
you
could
have
a
much
much
simpler
specification
of
what
it
is.
Why
did
you
you?
Could
you
could
you
could
you
could
simplify
this
to
to
a
fewer
fewer
primitives?
So
let
me
click
on
AWS,
for
instance.
E
But
when
you
think
about
it,
lots
of
these
they
can
many
of
these
mechanisms
have
a
lot
in
common
right
and
primitives.
You
need
to
implement
these
mechanisms.
Are
things
like
try
catch
loop
in
counting
all
right?
So
if
you
can
support
counting,
looping
and
and
and
catching
errors,
then
you
can
express
all
of
these
versions
of
the
mechanisms
with
backup.
E
You
know
you
need
delays
as
well
as
you,
as
you
pointed
out
in
the
presentation,
but
you
can
describe
all
these
policies
with
exponential
back-off,
with
n
retries
will
retry
for
one
minute,
etc,
etc,
etc.
All
of
them,
you
can
express,
as,
as
you
know,
derived
instruct
on
top
of
these
primitive
constructs.
So
so
maybe
this
is.
E
F
Thanks
very
much
for
the
demo,
an
example
what
you
were
talking
about
in
the
difference
between
the
language
representation.
It
looks
like
you
have
Python,
coming
and
JavaScript
right
now
and
the
underlying,
like
underlying
representation
of
how
to
process
these
things.
It
reminds
me
a
lot
of
the
way
that
internally,
at
Google
Borg
has
a
very
complex
protocol
buffer
that
expresses
how
you
should
run
things,
but
then
there
are
higher
level
tools
that
actually
compile
down
to
that,
and
everyone
uses
the
higher
level
tools
and
no
one.
F
E
E
So
what
promise
cut
your
clouds
that
that
is
well-defined
I
mean
again,
the
documentation
is
working
progress,
but
the
intent
is
for
that
to
be
specified,
well
define
fixed
or
you
know,
Mona
Mona.
Well,
we
add
stuff
to
it.
We
had
more
capabilities,
maybe,
but
we
this
is
backward
compatible.
Now
the
the
you
know
at
runtime,
we
end
up
building
a
finite
state
machine
out
of
that
representation.
That,
on
the
other
end,
is
not
intended
to
be
a
stable
representation.
This
is
something,
for
instance.
E
E
A
So
I
think
you
know.
So
if
we
had
any
questions,
if
not
all
right
to
go
comments-section
on
the
spec,
can
you
see
my
spec?
Can
you
see
the
document?
No.
A
Good
okay,
so
let's
go
through
this
comment.
I
think
we
addressed
some
comments
in
the
master
in
the
last
meeting.
So
let
me
first
go
through
the
meeting
minutes,
so
the.
A
Here
is
not
not
here:
oh
I,
think
you
have
a
comment
saying
order
to
express
sequence
of
function,
execution
for
each
parallel
branch,
sequence
of
function,
execution
each
parallel
branch
to
the
measure
with
the
approval
action
field
rather
than
a
single
dimensional
array.
Okay,
so
could
you
clarify
a
little
bit
on
that
I'm?
Not
here?
Oh.
A
Let
me
have
this
I
think
that
we
have
this
action
here
right
hold
on
just
here.
No,
these
are
those
are
example.
Are
you
talking
about
this
or
where's?
Your
comment
here.
G
G
G
G
G
A
Okay,
another
comment
on
this,
so
I
think
your
case
is
you
know,
okay,
so
you
give
some
example
right,
so
if
your
parent,
actually
in
parallel
state
such
as
a
B's,
so
ABCD,
okay,
so
so
yummy
is
a
b
c
d
is
executed
in
parallel.
These
are
four
functions
right.
This
is
what
you
mean
by
four
functions
right,
yes,.
A
G
E
Think
this
is
also
one
of
the
place
where
it's
easy
to
define
a
few
constructs
but
later
realized
that
they
are
not
flexible
in
us.
So,
for
instance,
you
know
the
parallel
composition.
If
we
need
things
like
timeouts,
we
definitely
need
need
things
like
in
all
use
cases.
We
see
cases
where,
in
a
parallel
composition,
there
are
branches
that
are
me
and
branches
that
are
must
right.
That
means
you're
trying
to
do
different
things
in
parallel.
Some
of
them
have
to
succeed
before
you
can
continue.
E
Others
you're
willing
to
sacrifice
if
they
don't
finish
on
time.
That's
one
example:
we
have.
We
have
maps
where
the
parallel
tasks
are
the
same,
but
the
data
is
different
as
opposed
to
having
different
you
know
and
as
opposed
to
having
the
dual,
where
you
have
the
same
data
but
different
tasks.
So
there
are
lots
of
lots
of
ways
to
build
quality,
constructs
and
I.
Think
it's
important
to
try
to
extract
what
are
the
primitive
operations
on
them
in
you
know,
what's
the
semantics
adjoining
semantics
rights,
this
might
be
one
way
to
do
it.
E
Another
thing
we
also
see
in
some
of
your
most
advanced
use
cases
and
maybe
I'll,
add
that
to
the
document
is
sometimes
you
fork
to
you,
you
you
haven't
of
execution.
They
need
folks
into
two
separate
tasks
and
then
one
of
these
tasks
further
Forks
into
two
separate
tasks,
but
the
order
in
which
you
want
to
join
the
tasks
that
you've
worked
is
not
the
order
in
which
you
fork
the
tasks.
So
if
you
only
have
these
constructs
that
are,
you
know,
matching
beginning
and
ends
of
a
parallel
composition,
then
you
cannot
express
that.
A
E
A
For
someone
here
we
have,
you
know
different
match
criteria
and
retry,
and
these
for
different
functions
right
so
different
function.
Result
you
know
the
based
on
the
different
function.
Result
like
you
know.
If
the
function
is
secure,
is
you
know
different?
This
is
a
array
so
different.
The
result
could
have
different
retry
support,
independent
retry
mechanism.
A
E
A
A
This
for
this
one,
so
as
you
know
so
here
on
I
think
you
know
trying
to
see
whether
and
other
people
have
any.
B
A
E
Agree,
this
is
an
important
question
and
the
way
we've
done
it
is
to
permit
writing
small
pieces
of
code
that
kids
run
in
line
that
doesn't
have
to
be
declared
as
function
but
running
between
the
functional
quiche
and
an
interesting
question
is
what
the
language
in
which
to
write
this
function
and
so
Amazon.
As
a
specific,
you
know,
J'son
path,
way
to
specify
JSON
path,
I
think
in
general
we
can
have
a
something
like
JQ,
for
instance,
to
specify
this
it's.
E
What
we
do
for
now
is
to
use
JavaScript
or
Python
specify
these
things,
but
there
are
drawbacks
to
making
these
these
include
output
adapters
too
flexible,
because
if
they
are
very
flexible,
then
running
them
safely
requires
a
lot
of
sandboxing
a
lot
of
runtime
resources
that
can
be
avoided.
If
this
is
a
more
specialized
language.
A
D
What
why
you
look
for
it
I
just
have
like
a
question
so
yeah.
This
does
seem
like
a
like
a
pretty
notable
problem.
I
hadn't
thought
about
it
before
sorry
for
not
reaching
all
the
way
to
the
part
of
the
dock,
and
so
like
I'm
wondering
is
this
something
that
the
spec
needs
to
handle?
Is
this
something
that,
like
every
implementation
can
handle.
D
A
So,
actually
on
I
think
this
is
an
important
point.
So
information
passing
from
one
function
to
another
function,
also
information
passing
from
the
event
event.
Information
could
be
the
payload
and
make
a
data
to
the
function.
I
think
these
two
we
all
need
to
address,
I,
think
I
put
it
here,
but
I
cannot
maybe
I
didn't
put
it
in
okay,
I'm
going
to
put
it
in
and
then
later
people
can
see
whether
that
works.
A
E
Yes,
so
sorry,
so
we
first
we
follow
from
the
open
with
conventions
so
in
open
with
what
every
function
produces
adjacent
dictionary,
so
either
this
JSON
dictionary
is
a
fields
name
error
or
not.
If
it
doesn't
that's
considered
to
be
normal
results,
if
it
does,
that's
considered
to
be
an
abnormal
result.
So
if
you
have
this
the
example
I
was
showing
earlier,
for
instance,
if
you
have
the
normal
results,
then
you
execute
to
sing
frequence.
After
with
the
output
of
the
previous
function
being
the
input
of
the
next.
E
A
Okay,
I
think.
Let
me
address
this
quickly,
so
for
the
for
the
for
this
arrow.
If
the
function
has
an
arrow,
we
have
it
here
say
it's
a
it's.
A
retrial
here
is
that
it's
a
retry
mechanism
which
say
you
know
you.
The
function
result
match
what
we're
you
and
then
you're
going
to
do
the
rich
y
for
the
information
passing
it
doesn't
matter.
If
the
user
just
say:
okay,
I,
want
information
passed
from
this
function
to
the
next
function
or
from
an
event
to
a
function
or
from
between
the
states.
A
It
has
a
filter
mechanism,
say
what
which
part
of
the
information
is.
It's
a
function
result
or
it
is
a
previous
study
event.
It's
a
previous
state
information
from
previous
state
or
is
information
from
the
event.
We
all
first
apply
a
filter.
You
know,
because
you
might
not
want
to
pass
all
the
information
right.
You
may
want
to
pass
a
specific,
even
a
specific
part
of
the
information
field.
A
So
there's
a
future
there,
of
course,
if
the
filter,
if
you
would
have
known
so
that
means
all
the
information
you
want
to
pass
to
the
either
the
next
state
or
to
the
next
function
on
so
there's
a
filter
there
and
then
there's
a
after
apply
that
filter.
I
know
the
information
is
passed
to
the
next
function
on
to
the
next
to
the
next
state.
I
think
that
that's
how
it
he
you
know
they
use
a
specify.
A
A
Great
I
think
that's
all
you
know,
please
feel
you
know
free
to
post
comments,
I
think
that
that's
what
helped
us
you
know
make
this
that
better,
so
I
think
in
the
netting
we
are
going
to
mostly
just
concentrate
on
addressing
you
know
all
these
different
comments
to
see
how
we
can
improve
this
document
sounds
good.
Oh
okay,
right
is
that
we
can
I.
Think
we
well
I,
don't
really
Mickey
thanks.
Everyone
take.