►
From YouTube: CNCF Serverless WG 2020-02-17
Description
CNCF Serverless WG 2020-02-17
A
A
B
B
A
C
A
B
A
D
A
A
C
F
B
F
I
mean
I
was
hoping,
maybe
today,
if
you
guys
feel
like
it,
it's
your
decision
really
so
yeah.
It's
up
to
you
guys
I!
Think
it's
a
good
starting
point,
not
because
I
want
to
speak
or
I
want
to
do.
Anything
is
just
because
I
think
for
even
people
they're
getting
involved
their
last
meetings,
kind
of
took
off
with
different
agendas,
and
this
is
a
good
kind
of
starting
point
for
new
people
getting
involved
to
see
why
or
what
or
who
or
start
raising
questions.
F
C
F
Yeah
regarding
the
event
state
Kathy
I
just
wanted
to
let
you
know
maybe
you've
seen
already
I
have
closed
their
pool
request,
with,
like
five
billion
comments
on
there
I've
taken
all
those
comments
in
consideration
and
I've
raised
a
new
pool
request
which,
with
even
two
examples
which
cover
the
two
examples
that
you
are
have
mentioned
in
the
comments
Kathy,
so
those
should
be
covered
and
not
really
so
far.
I
got
some
comments
from
Doug,
but
if
you
guys
want
to
start
looking
at
their
PR
and
providing
more
comments,
I
would
like
that
as
well.
F
A
So
I
think
you
know
yeah
for
these
two
topics.
Probably
we
can't
take
it
off,
because
this
was
originally.
You
know.
Pr
I
think
the
home
was
PR,
but
since
he
has
closed
that
and
then
create
a
new
one,
so
we
can
probably
start
to
because
because
the
new
one
is
you
know,
so
what
is
that
P?
So
we
you
mind
the
post
that
new
PR
here
I
think
this
VI
is
closed
right,
home
yeah.
It's
alright.
F
F
A
A
A
A
F
F
The
event
state
has
to
act
once
you
declare
you
you
you
do
it
kind
of
like
a
gateway,
it's
exclusive,
so
one
of
the
branches
will
trigger
or
is
parallel
in
your
case,
that's
and
and
which
all
of
the
events
must
be
present.
In
order
for
actions
to
execute,
there
is
also
difference
between
a
few
events.
F
State
is
a
starting
state,
which
means
the
triggers
initiation
of
the
workflow
or,
if
it's
an
intermediate
state,
which
is
you
know,
it's
it's
it's
a
transition
from
another
state,
so
a
workflow
is
Authority
exists,
so
all
that
is
covered.
I,
put
examples
that
put
images,
and
so
it's
much
more
in
detail
and
more
understandable
at
thing
than
the
original
one
day
apparently
creates
a
lot
of
confusion.
F
So
yeah
take
a
look
at
it
now
and
then
then,
and
whenever
you
have
time
and
then
put
some
comments
on,
there
are
see
where
we
go
from
there.
Okay
III
do
want
to
link
one
more
in
the
chat.
If
you
guys
don't
mind
that
I
think
it's
important,
which
is
the
one
sixty,
because
it
updates
the
specification,
use
cases
and
I
would
love
to
get
comments
on
that
as
well,
because
I
think
the
use
case.
F
This
is
one
of
the
first
things
that
people
look
at
and
the
ones
they
were
there
before
they
were
okay,
but
they
were
more
like
examples.
Rather
than
specifics.
There
were
less
use
cases,
so
you
know
I
updated
those
added
four
or
five
new
ones,
and
if
you
have
any
more
ideas,
either
put
them
in
comments
of
the
PR
or
or
feel
free
to
do
your
own
PR
with
adding
more
use
cases
be
great
as
well
yeah
if
we
can
maybe
discuss
their
160
as
well.
At
some
point
during.
F
C
A
F
F
I,
don't
know,
I
wanted
to
show
you
some
of
the
key
concepts
of
this,
that
I
have
been
presenting
to
new
people
and
kind
of
get
your
input
on
it
or
give
you
ideas
what
you
can
present
as
well.
If
you're,
you
know
talking
about
this,
to
whoever
I
usually
just
give
a
small
introduction
to
service,
that's
kind
of
all
of
you
guys
know,
but,
and
you
will
see
why
pay
for
value,
and-
and
this
is
something
that
I
want
to
show
the
slide
on,
because
the
pay
for
value
for
work
flows
in
several
areas.
F
F
The
way
I
show
why
serverless
workforce
is
important
is
by
showing
a
function,
a
surrealist
function,
and
this
is
just
an
example
of
a
c-sharp
function
and
what
I
say
to
people
is
look.
What
is
the
service
for
is
supposed
to
work
was
doing,
general
is
offload
the
business
orchestration
and
you
to
do
your
functions
and
your
code
that
you
deploy
and
runs
in
service
environments
to
really
focus
on
business
logic.
F
But
if
you
look
at
a
lot
of
these
functions,
you
do
everything
else,
but
business
logic
and
in
this
case,
I'll
show
quickly
that
looky.
This
is
a
function
that
gets
deployed
on
Microsoft
Azure,
whatever
I'm
not
trying
to
bash
Microsoft.
Here,
please
don't
either,
but
it's
a
good
example
to
show
that
you
have
a
definition
of
an
event.
In
this
case
a
timer
trigger.
You
have
to
configure
the
cron
job.
You
have
to
configure
your
services
that
you're
going
to
call.
You
have
control
flow
logic
in
the
await
statement.
F
Do
we
do
something
in
parallel?
Do
we
do
it
synchronously
asynchronously,
then
you
have
a
can
control
for
logic
in
the
for
each
loop.
That
goes
through
some
list
of
to-do
items
and
and
completes
the
ones
they
deletes
the
ones
that
have
been
completed.
So
if
you
look
at
the
server
list
function,
you
have
you,
don't
actually
do
any
business
logic
in
here.
F
Why
is
this
thing
in
red
flow
control
patterns,
as
we
all
know,
and
we
have
some
big
guns
in
here:
they've
been
around
workflows
for
decades,
for
we
have
developed
many
many
workflow
patterns
for
control
for
logic,
for
data
access
for
error
handling
you
maybe
there's
hundreds
of
them
even
for
a
simple
fork
and
joined
there's
over
40
of
it.
But
why
is
that
important
in
serverless
environment
is
because
of
the
cost.
F
A
similar
pattern
of
billing
having
a
surrealist
workflow
in
place
does
not
mean
the
cost
is
going
to
be
reduced,
because
now
you
have
your
cost
of
functions
and
workflows,
but
where
control
flow
patterns,
and
why
this
workflow
stuff
is
so
important
for
service,
specifically,
is
the
cost
itself,
and
you
see
here
an
example
that
introducing
simple
control
flow
pattern
like
like
a
fork,
can
seriously
reduce
your
cost
of
the
new
stuff
in
service
environments.
So
in
case
we
can
say
step
two
in
this
case
that
there
does
nothing
can
be
avoided.
F
Another
thing
is
scaling.
If
we
go
back
to
here,
things
like
event,
states
that
actually
trigger
work
for
Association,
we
have
to
have
the
ability,
such
as,
for
example,
this
referencing
something
else
rather
than
using
some
sort
of
string
pattern
scale.
So
our
service
work
will
have
to
scale
to
be
able
to
scale
to
zero
in
weight,
States
and
then
continue.
So
a
lot
of
the
work
that
I
think
I
will
be
doing
in
the
near
future,
and
everybody
else
hopefully
can
get
give
input
and
also
work
on.
F
So
please
be
aware
of
this
cost
right
as
far
as
who's
out
there
I
put
all
these
images,
you
can
tell
me
to
remove
you
or
something,
but
there
is
a
lot
of
this
of
this
stuff
going
on
right
now,
every
month
there
is
like
I
said
a
new
workflow
popping
up,
and
why
are
we
important
in
this
space
is
because
provide
the
standards
and,
like
I,
said
before,
if
we
don't
do
it,
somebody
else
will.
This
is
not
something
that
it's.
F
E
A
E
F
Is
probably
not
clear,
but
that's
kind
of
like
the
main
point,
and
and
then
we
we
say
you
know
basically
I'm
trying
to
say
you
have
all
these
different
workflows.
They
all
use
Jason,
they
all
using
a
mold.
They
all
use
whatever,
but
at
the
end,
they're,
not
proprietary,
they're,
not
portable
they're,
not
vendor
neutral,
and
you
are
basically
vendor
stuck
once
you
pick
a
solution
within
you
know
your
company,
or
or
whatever
you're
doing,
and
that's
kind
of
the
value
of
service
work
for
a
group
and
service
work
for
specification.
F
That's
it
and
I
kind
of
go
into.
You
know
what
it
is
you
will
see
during
the
demo
and
I
really
want
to
emphasize
about
human
readability.
I
think
that's
another
big
from
what
I've
been
asking
quite
I've
been
asked
questions
during
those
meetings.
A
lot
of
people
are
long-term
BPM
and
to
users
and
I:
don't
want
to
get
into
any
worse
with
that
or
because
I
have
been
around
bleep
even
to
myself
for
a
very
long
time.
So
that's
irrelevant
to
me,
but
human
readability.
F
It
was
a
big
thing
and
I
just
go
through
different
things.
Like
the
states
this
that
we
have
the
branching
and
stuff
like
that
at
the
end,
I
show
a
demo.
So
this
is
kind
of
like
the
the
presentation
that
I
have
I'll
post
it
once
I
remove
the
the
footer
and
some
of
the
stuff
regarding
the
had
specific.
That's
that's
here,
Tana
like
I
removed
that
as
well
and
then
you
guys
can
can
can
add
to
it
or
give
comments
or
whatever
but
I,
and
that's
it
for
the
slides.
F
F
All
right,
so,
let's
see
this
bad
boy
in
action.
Let
me
just
delete
my
test
that
I
did
yesterday,
but
what
I
have
here?
You
don't
have
to
be
a
developer.
To
understand.
I
have
a
simple
maven
project.
He
has
no
Java
classes.
He
just
says
resources
which
are
some
JSON
files.
In
this
case,
our
service
workforce
is
the
specification
defined
can
be
either
presented
in
JSON
format
or
Yamma,
which
we
added
recently
either
is
fine,
because
I
think
Alibaba
uses
the
animals.
F
Specifically,
we
have,
to
kind
of
you
know,
cater
to
both
sides
of
the
markups,
which
is
fine.
Now
this
is
just
an
implementation
which
we
have
say
anything,
but
you
don't
have
to
have
any
Java
classes.
You
don't
have
to
have
any
setup.
You
just
create
a
project.
It's
running
on
this
thing
called
Quercus,
which
you
can
read
about
as
well,
but
we're
just
going
to
create
greeting
dot.
Sw
does
Jason
is
our
extension.
You,
our
implementations,
can
use
a
different
extension
because
we
don't
want
to.
We
have
a
hot
reload
feature.
F
We
want
a
hot
reload
and
every
single
JSON
file,
because
you
might
not
be
a
service
workbook,
so
we
do
SW,
doe
Jason
and
let
me
see
if
I
can
get
in
presentation
mode
all
right,
so
you've
seen
the
specification
you're,
seeing
all
these
mazie
documentation,
but
now,
let's
see
what
the
heck
this
actually
looks
like.
Of
course,
we
are
representing
our
word
close
with
Jason,
so
it's
adjacent
object.
Every
workflow
has
should
have
an
ID
and,
let's
call
it
greet
alright
we're
doing
a
simple
greeting
hello.
F
Somebody
work,
a
work
well
already
is
a
name
and
of
course
we
have
to
have
a
start
state.
Ok,
so
this
is
the
starts
at
property.
So
it's
a
great
person
alright.
Now
another
thing
that
we
have
to
do
is
oh
yeah,
and
also
we
can
specify
a
version.
It
doesn't
matter
really,
so
you
can
version
your
workflows
and
also,
if
you
you
know,
update
it
and
stuff
like
that.
The
next
thing
we're
gonna
do
is
we
have
these
things
called
functions
now?
These
are
the
service
functions
that
we
can
invoke.
F
We
have
done
this
in
our
specification,
which
is
a
changed,
for
example,
to
AWS
and
I.
Think
this
is
a
great
do.
We
have
reusable
definition
of
functions.
We
have
a
lot
of
different
states
like
operation,
States
events
States
stuff,
like
that
they
can
have
actions
and
actions
can
call
a
function
in
AWS,
for
example,
or
other
ones.
You
have
to
redefine
your
functions
over
and
over
again
in
each
action.
We
have
this
little
bit
ability
to
define
a
reusable
function.
F
Alright,
and
let's
give
it
system
out
function,
you
can
give
it
a
type
or
the
resource.
Now
in
my
implementation,
because
I
miner
and
it's
like
I,
don't
wanna
actually
call
a
service
function.
I'm
just
gonna
I
have
a
assist
I'll
type.
This
is
just
gonna
print
stuff
out.
So
this
is
a
definition
of
a
function.
Now
that
can
be
reused
throughout
the
workflow
states.
Alright
and
now,
of
course,
we
have
to
have
our
state's
alright,
so
we
have
many
different
states
and
each
state
has
a
name
now.
F
Let's
call
it
the
same
as
what
we
said,
the
starting
point
or
the
start
state
or
workflow
is
we
have
different
states
types
as
you
can
see
these
the
currents,
types
that
we
have.
Alright,
we
can
add
more
if
we
need
to,
but
what
I'm
using
right
here
is.
Vs
code
is
just
an
editor
and
because
our
specification
has
a
very
specific
jason
schema
definition,
we
can
write
simple,
tooling
to
do
stuff
like
this.
Alright,
so
it
basically
fills
you
all.
The
options
that
are
json
schema
defines,
which
is
another.
F
What
I
have
to
say
addition
to
what
BAW
a
state
language
has?
They
don't
have
adjacent
definition
for
this
we
do
and
I
created
a
small
little
vs
code
extension
that
helps
me
with
this.
So
let's
do
a
simple
operation
state.
If
you
guys
remember,
operation
state
is
just
to
state
the
execute
actions.
Okay,
an
operation
state
could
have
an
action
mode.
Let's
call
it
sequential,
and
an
action
state
can
have
actions
oops,
don't
actions.
Alright,
so
now
we
have
our
actions.
Another
thing
before
we
define
our
actions,
we're
just
going
in
our
service
work.
F
F
We
send
a
cloud
event
out
at
the
end
of
our
execution
of
the
workflow
in
this
case,
I
have
a
signal
which
makes
sense
for
our
implementation,
but
it
doesn't
make
sense
for
the
workflow,
but
it
terminate
is
a
heart
in
so
when
we
execute
all
our
actions
in
this
state,
we're
just
going
to
terminate
the
execution
of
our
workflow
instance.
So
far,
so
good
guys.
F
No,
please
stop,
but,
as
you
see
right
now,
this
is
all
human
readable,
so
far,
I'm
just
explaining
it
as
you
go,
because
it
might
be
the
first
time
for
some
people
to
see
the
and
next
time
I
won't
bother
with
this
anymore.
But
now,
let's
finish
this
and
see
running
and
then
we'll
go
from
there.
Now,
let's
create
an
action,
an
action
has
reference
to
our
function,
and
this
is
something
we've
added.
F
As
far
as
the
reusable
functions
go
so
I
can
say:
I
am
going
to
whoops
reference,
my
system.out
function,
but
of
course,
I
can
pass
it.
My
own
parameters,
all
right,
no
parameters,
just
an
object.
You
can
have
string,
keys
and
string
values.
In
this
case
we
can
have
I
think
this
one
takes
a
prefix
of
hello,
we're
just
gonna
greet
somebody
and
a
message
parameter,
and
this
is
something
that's
kind
of
confusing
I.
F
Think
to
some
people
mention
this,
but
it
is
that
a
workflow
data
when
we
start
or
workflow,
we
will
give
it
some
JSON,
which
is
the
workflow
data
that
starts
this
workflow
data
is
then
going
to
be
passed
as
the
data
input
to
the
starting
state,
in
this
case
our
greeting
person
state
at
this
point.
It
is
available
to
this
state
and
we
can
reference
it.
Okay,
we
don't.
F
We
can
also
filter
it
and
that's
where
the
state
filters
and
all
the
different
filters
come
in
that
I'm
not
gonna
talk
about
now,
but
let's
say
we
just
want
to
and
we
reference
with
a
dollar
sign,
and
we
just
want
to
say
hello
first-name,
and
this
is
really
it
at
this
point.
Our
workflow
is
executable.
F
F
Just
gonna
start
Quercus:
this
is
the
is
going
to
our
implementation
right
here
it
looks
at
the
workflow
it's
going
to
compile
it
into
some
internal
API
that
nobody
cares
about
and
make
it
executable.
Now.
The
cool
thing
about
implementations
they
want
thing
you
have
to
understand
is
how
our
workflows
instantiated.
We
have
things
like
sea
alive.
We
have
things
like
that,
but
in
most
cases
in
the
real
life
environment
is
going
to
be
actually
instantiated
via
for
probably
a
some
REST
API,
either
some
service
or
something
what
we
have.
F
We
generate
a
REST
API
in
case
of
us
for
things
like
the
work
flow
instance,
any
event
State,
which
is
a
wait
state
things
like
that
in
in
this
case,
we
have
our
greet.
Is
this
that
let
me
just
double
check,
yeah
great,
so
the
IDS
greet
so
we
have
generated
rest
AP
arrest,
endpoint
for
greet
we're
just
gonna.
Try
it
out
we're
just
gonna,
say.
F
Alright,
so
what
I'm
doing
now
is
I'm
sending
Jason
to
this
rest,
endpoint
called
greet
passing
in
first
name
is
my
name
and
we
should
create
an
instance
of
this
workflow
and
Here.
I
am
are
worth
look
at
executed
and
I
got
yellow
tea
food.
Okay.
Now
one
cool
thing
about
service
workers
that
are
just
usually
showing
meetings
is
that
we
have,
if
we
don't
have
to
restart
our
applications
and
stuff
like
that,
so
it's
very
easy
to,
for
example,
add
in
other
states.
F
So,
let's
add
whoops,
that's
not
a
state,
let's
add
another
state,
all
right
and
then
I'll
get
to
the
to
the
good
stuff.
Don't
worry
well,
what
am
I
done
here?
Okay,
okay,
paste
right!
All
right
so,
let's
say
add:
another
operation
state
now,
instead
of
end
here,
we're
gonna
have,
let
me
just
do
presentation
mode
instead
of
end.
F
We're
going
to
have
a
transition
on
transition
is
going
to
have
a
next
state
of
send
off
person,
let's
say
and
we're
going
to
transition
to
the
another
operation
state
which
has
the
same
function,
but
we
here
say
goodbye
and
that's
it
we
can
send
another
rest.
Endpoint
request
to
this
to
start
a
workflow
instance,
and
here
we
are
with
goodbye.
So
this
is
the
basic
kind
of
hello
world
example
that
you
can
show
to
people.
F
It
takes
seriously
like
three
minutes
to
code
and
actually
run
depending
on
your
implementation
now
to
some
of
the
better
stuff.
To
actually
show
people
here
is
I
have
some
other
examples
and
because
they're
a
little
longer
I,
don't
type
them
up
myself
by
the
heaven.
But,
as
you
can
see,
there
are
only
40
lines
long
in
this
case.
F
What
we
have
is
use
of
event
State,
and
this
is
what
kind
of
event
state
is
important
in
this
case,
what
we
want
to
do
is
have
a
workflow
get
instantiate
it
on
a
cloud
event
coming
through
a
Kafka
pipe
and
also
at
the
end
of
the
work
where
you
want
to
produce
a
cloud
event
which
going
to
trigger
our
other
workflow.
So
this
is
kind
of
like
a
inter
work
for
a
messaging
based
art
orchestration,
where
our
workflows
can
consume
events
via
the
starting
event
state
or
in
your
immediate
event.
F
F
We
have
also
just
like
functions.
We
have
reusable
events
in
this
case
we
have
two
events
defined.
One
is
the
customer
arrives
event
which
is
a
comes
from
or
Kafka
stream
that
is
defined
and
while
workflow
completes,
we
have
a
customer
departs
event,
which
also,
you
know,
is
a
Kafka
based
event.
We
have
the
same
type
of
function,
which
is
our
system
out,
but
in
this
case,
instead
of
reacting
to
or
getting
instantiated,
we
are
REST
API
passing
in
some
JSON.
F
So
this
is
the
same
type
of
state,
which
just
says
hello
and
at
the
end
the
only
thing
that's
different
is
their
end.
Instead
of
being
typed
terminate,
we
have
a
type
message
and
we
reference
an
event
that
we
have
defined
here,
which
needs
to
be
produced,
passing
it
in
some
information.
Okay,
now
this
produced
customer
departs
event
is
going
to
be
then
consumed
by
our
departure.
Workflow,
we
just
as
goodbye.
F
So
it's
the
same
type
of
thing
that
we
just
showed
within
our
greeting
workflow,
but
instead
of
REST,
API
and
Jason,
we
are
reacting
to
messages.
So,
let's
kind
of
see
how
that
ends
up,
we
have
I.
Have
my
zookeeper
running
I.
Have
my
Kafka
locally
running
here:
I
just
have
to
create
now
I
am
connecting.
This
is
a
console
producer.
This
allows
me
to
send
messages
to
my
Kafka
topic
and
because
our
workflow
here
arrival
has
a
topic
defined
of
arrival
I'm
going
to.
F
F
And
in
this
case,
let's
Saleh
boy,
okay-
and
this
is
actual
cloud
event
format-
the
only
thing
I'm
doing
is
is
sending
the
data
section,
which
is
the
payload
of
visa.
Now,
when
I
send
that
event,
if
you
can
see,
we
said
hello
cell
boy,
they
came
from
our
arrival,
which
reacted
to
the
arrival
message.
If
you
can
see
now,
our
arrival
workflow
at
the
end
has
sent
I'm
sorry,
our
customer
departs
event
which
you
can
can
see
here.
F
F
C
F
Actually,
well,
this
is
implementation
specific
you
don't
have
to,
but
within
the
the
runtime
that
we
have
for
this,
we
have
force
cloud
events
hundred
percent,
so
you
actually
like
have
to
send
the
cloudy
then
format.
We
use
the
cloud
event,
a
Java
API
to
convert
their
message
into
cloud
event,
object
and
then
consume
it.
It's
payable
yeah,
that's
it
yeah.
B
F
G
E
F
E
G
Thanks
for
the
demo,
it's
really
really
nice
to
see
this
running
while
you
were
presenting
the
second,
the
more
complex
scenario,
I
was
thinking
about
this
events,
definition
at
the
beginning
of
the
workflow.
How,
with
your
workflow
instance,
would
you
also
subscribe
to
the
departure
topic?
Is
that
happening
underneath.
G
F
H
F
Well,
the
events
can
be
there
consumed
or
produced
by
the
workload
they
can.
The
only
way
of
workflow
can
produce
currently
in
our
specification
and
a
cloud
event
is
in
DM.
State
is
when
the
workload
finishes
execute.
That's
the
current
way,
if
there's
other
ways
that
we
should
be
doing
it
I'm
all
ears.
For
it,
the
only
way
to
consume
is
the
event
states
currently.
F
G
This
end,
semantics
of
saying,
emit
a
message
to
me
seems
like
a
collapsed
version
of
transitioning
to
a
state
that
would
submit
a
message
right
so
or
an
event.
Maybe
we'd
call
it
a
better
call.
It
event
not
message
because
it's
so
I
mean
is
it?
Is
it?
Do
you
just
submit
any
search
to
a
Kafka
topic,
or
do
you
actually
encapsulate
it
as
a
cloud
event?
G
G
F
Know
business
process
main
BPMN
to
where
you
have
different
types
of
United,
States
I
mean
n
states
right,
you
have
a
and
the
event
you
have
a
message
and
event
signal
and
event
things
like
that.
Now
we
can
borrow.
This
is
like
the
whole
point
of
us.
What
we're
doing
our
benefit
towards
other
portal,
like
even
AWS,
is
because
we
have
a
lot
of
minds
here.
They
have
been
seeing
different
types
of
workflows
implementation,
so
the
more
we
can
borrow
from
our
experience
and
our
good
experiences.
It's
good.
So.
F
Currently,
no
we
with
there
is
such
thing
in
BPM
and
to,
for
example,
in
intermediate
events
where
you
can
send
messages
and
consume.
If
you
guys
would
like
to
add
that
this
is
why
I'm
doing
this,
to
give
you
guys
ideas
for
pull,
requests
and
and
issues
and
stuff
like
that,
because
the
we
can
add
a
lot
of
yes,
we
can
add,
there
is
need.
A
G
Press
too
much
on
adding
stuff.
So
if,
when
there
are
people
using
it
actively,
I
think
this
is
where
most
of
the
because
I'm
not
a
developer.
That
has
build
an
application
based
on
the
current
workflow
specification.
Nor
do
we
have
a
product
on
it.
So
I
am
agitating
to
just
propose
stuff
for
completeness
of
functionality,
purposes
or
whatever,
and
then
just
just
troubles
every.
E
G
Like
Legos
like,
if
I
want
to
be
able
to
emit
an
event,
currently
I,
the
only
way
possible
is
to
implement
it
as
part
of
my
function.
Implementation
with
the
termination
with
an
event
yes,
but
I,
can
only
terminate
with
an
event.
I
cannot
omit
an
event
and
then
continue
the
workflow.
So
I
was
thinking
about
any
way
to
implement.
So.
C
C
G
And
the
send
receive
would
also
touch
on
the
borders
of
the
work
flow
extent
right.
So
you
can.
We
have
this
longer
discussion
about
consuming
events,
but
I
think
it's
the
same
with
creating
events.
Would
they
be
carrying
the
same
correlation
ID?
Would
that
be
stripped
off?
Is
that
part
of
the
workflow?
How
do
you
currently
manage
so.
F
Well,
the
way
we
have
it
defined
in
the
specification
is
two
ways:
okay,
one
is
starting
a
workflow
instance
where
you
don't
have
a
correlation
key,
and
that
is
I
think
what
a
lot
of
the
comments
during
that
G
are
like
50,
common
JIRA.
At
that
point,
we
have
a
token
that
you
can
or
cannot
use
once.
A
work,
for
instance,
is
started
is
within
implementation
that
you
have
a
correlation
key.
You
might
have
multiple
coloration
keys.
One
is
for
the
work,
for
instance
yourself.
What
AWS
is
doing?
F
They
also
have
a
specific
task
relation
key,
so
they
can
start
the
work,
for
instance,
back
up
once
it
scale
to
zero
on
a
specific
task
or
a
wait
state
that
the
workflow,
where
it
scale
to
zero,
so
I,
don't
know
we
have
to
define
it.
But
currently,
if
you
have
an
event
state,
it's
not
a
starting
state.
You
want
to
consume
events,
they
have
to
include
a
correlation
key,
so
they
are
associated
with
that
particular
instance
of
the
workflow.
F
G
G
A
G
E
G
One
notice,
I
I,
noticed
the
end
and
or
and
still
I
wanted
to
ask
Casey
actually
and
if
you
we
can
do
it
through
github
issues.
But
my
question
is
when
we
do
get
to
events
like
we
need
to
end
on
or
we
need
to
get
that
boolean
expression
right.
The
first
event
has
happened.
Who
keeps
the
state
about
that
event?
Having
happened
already
would.
A
E
A
So,
okay,
so
here's
my
thought
so,
if
they're
on
the
work
floor
across
two
events
right,
you
say
these
two
events,
I
am
right.
So
the
first
event
comes:
it's
a
workflow
engine,
okay,
all
the
whatever
you
create
the
backend
workflow
back
and
implementation.
That
needs
to
keep
track
of.
You
know
which
events
has
been
received.
For
example,
event
a
has
been
received.
We
keep
track
and
wait
and
then
wait
for
the
next
event
and
then,
of
course,
we
have
a
time
up
right
for
the
event
as
a
whole
right.
A
So
if,
within
that
time
period,
the
second
event
has
not
been
received,
and
then
you
know
there
should
be
a
specification
said
when
that
time
thought
was
what
action
we
should
do
or
what
which
transition?
We
should
go
I.
Think
currently,
the
span
is
positioned
to
an
end
State,
but
we
can
extended,
say
if
you
know
his
events
are
not
received.
We
can
transition
to
another
state.
We
can
extend
it,
provide
more
options.
A
current
spec
I,
just
say:
okay,
in
fact,
event
is
not
I
mean
it's
not
all
events
I
received,
which
transition
state.
G
Okay,
that
is
when
I,
when
I
transition
out
of
the
event
state,
which
would
be
because
of
a
timeout
or
because
it
has
been
completed,
then
I
can
actually
get
rid
of
the
state
because
it's
no
longer
needed
okay
and
then
the
other
night
yeah,
okay
yeah.
Maybe
let's
take
these
discussions
to
the
issues
and
pull
requests?
That's
okay!.
F
A
C
A
Think
you
know:
ok,
yes,
also,
we
can
discuss
about
that.
I
think
the
first
thing
everyone
on
the
state,
because
we
would
like
every
state
to
be
able
to
emit
the
event
I
think
the
first
thing
we
should
do
is
pretend
the
and
the
flower
well
understate,
I.
Think
the
homeo
immersion
that
you
are
going
to
change
it
right
change
it
back
right,
we'll
eat
understate.
Is
that
what
you
have
you
done
that
all.
F
A
F
Yeah
there's
many
ways
you're
right
either.
Somehow
Avery
state
should
be
able
to
produce
an
event,
but
I.
Don't
think
states
like
what
we
have
some
states
should
not
probably
do
it
like
parallel
station
choice
stations.
Probably
not
do
it
passed
through
States
should
not
do
it,
I
mean
there's
some
states
that
really
I
mean
maybe
we'll
make
it
part
of
the
actions
such
as
just
like
a
function.
Execution
could
be
a
specific
action
that
produces
an
event
so
States
they
can
execute.
Actions
can
also
do
that.
A
Thank
you
for
not
the
not
allow
it
to
produce
our
event,
then
those
they
cannot
transition
to
that
dedicated
event.
Producer
state,
so
I
think
that
part
of
the
logic,
no
matter
how
we
define
you
there
so
as
oh
yeah
I,
think
that
that's
we
need
to
discuss.
You
know
which
state
should
not
have
should
not
be
involved
or
even
producer.
So
that's
one
thing.
Another
thing
is
you
know
how
we
should
define
whether
we
define
he
said
that
state
in
the
action
or
we
have
a
producer
state,
and
another
thing
is
that.
E
A
Should
have
that
and
state
because
I'm
just
feeling,
maybe
in
the
future,
we're
going
to
add
more
informant,
you
need
to
expend
that
and
to
have
more
functionality,
so
I
think
it
likes.
I
mean
it
is
clear,
like
you're,
not
even
exhaust.
Oh
I
see
that
you
show
right
have
to
take
these.
If
you
have
an
estate
there
you
do.
You
just
add
the
new
state
that
in
state
does
not
need
to
be
changed.
Otherwise,.
F
So
far,
my
testing
has
shown
that
adding
explicit
in
States
adds
on
the
bigger
workhorse
can
I
had
probably
hundreds
of
lines
of
JSON
code.
In
addition,
the
extension
to
ending
I
think
what
we
should
think
about-
and
this
is
just
my
thought-
is-
is
just
like
transitions.
Ending
a
workflow
can
add
more
rules
such
as
a
simplification
rules
such
as
user.
F
Like
not
there.
Anybody
can
end
the
work,
so
there's
a
lot
of
more
stuff
that
we
can,
you
add,
even
to
transitions,
for
example,
cannot
transition
from
state
a
to
be
unless
I'm,
a
specific
user
type
or
I
have
a
specific
role
or
a
group?
That's
one
thing:
there
are
specification
as
far
as
authentication
goes
does
not
cover
it
all.
Currently,
there's
a
lot
of
stuff
we
can
improve
on,
but
right
now
there
is
a
specific
need.
I
keep
it
like
this.
F
Until
we
find
out
hey,
we
really
need
to
add
it
back
or
something
like
that.
But
I
mean
yes,
yeah,
all
right
now,
as
far
as
n
States
being
a
generic
and
state
before
where
it
could
be
reused.
Yes,
we
can
have
one
and
all
of
our
states
contributing
to
it,
but
as
soon
as
we
start
introducing
States,
some
can
produce
messages.
In
some
case,
we
want
to
produce
an
error
in
some
case.
We
want
to
do
discs
then,
having
the
way
we
have
them
right.