►
From YouTube: Mesos Developer Community Meeting (August 31st, 2017)
A
A
A
C
B
B
B
Everybody
can
hear
us:
okay,
okay,
great
okay,
so
I
just
updated
the
agenda
a
little
bit
so
we'll
do
the
do
the
discussion
around
the
process,
semantics
for
future
discarding
and
abandonment
first
and
then
after
we
have
time
we'll
try
to
do,
try
to
review
the
community
Kanban,
and
then
we
can
talk
about
scheduling
a
documentation.
Hackathon
may
secure
love.
The
host
dates
might
make
sense
or
something
like
that
and
then
I'd.
B
Okay,
so
I'm
yeah.
This
should
be
fun.
We're
gonna
talk
about
the
semantics
of
abandonment
in
futures
and
and
some
of
the
upcoming
changes
that
we
want
to
make,
some
of
which
are
already
on
their
way
and
some
of
which
will
meet
to
the
good
discussion
about
other,
not
want
to
introduce
it.
So
this
is
the
space
of
the
agenda.
B
I
had
for
this
presentation,
so
first
just
getting
it
on
the
same
page,
about
how
discarding
aka
cancellation
works
in
the
process
for
futures,
then
discussing
how
discarding
interacts
with
future,
then
just
how
to
start
interacts
with
loop
and
a
wait.
This
new
thing
that
we're
gonna
introducing
called
undesirable
possibility
of
changing
the
semantics
of
a
future.
Then,
with
respect
to
the
discard
perspective,
discards,
a
potential
new
thing:
we
can
introduce
called
discardable
and
then
so
stuff
we've
been
doing
around
abandoned
minced,
which
is
cued
up
to
be
committed.
B
B
B
I'm
gonna
go
through
then.
If
we
were
to
discard
the
future
that
we
got
back
from
Fuu,
we
could
assert
that
the
future
has
a
discard,
as
well
as
the
discard
has
propagated
through
to
the
Future,
that's
associated
with
the
promise,
since
that's
the
teacher
that
has
returned
from
carnal
food
okay,
so
this
is
this
is
basically
requesting
the
discards.
This
is
requesting
canceled
canceled
cancellation.
This
is
trying
to
cancel.
This
does
not
mean
that
cancellation
is
actually
occurred,
so
I'll
try
sitting
overtime
with
a
future.
B
When
you
call
discard
on
a
future,
it's
basically
requesting
that
you
will
discard
that
future.
It
is
not
actually
discarding
the
computations,
so
the
that
this
is
really
important,
because
sometimes
you
can't
discard
asynchronous
computations.
Sometimes
a
solution
computation
where
I
started
like
I,
can't
cancel
it.
I
can't
discard
it,
so
somebody
might
request
it
and
I
can
just
be
like
well.
Sorry,
I
know
that's
what
I
can
do,
because,
because
you
are
because
the
action
has
already
started.
B
Okay.
So,
on
the
flip
side,
when
you
actually
want
to
decide
that
the
asynchronous
that
action
has
been
cancelled,
you
call
discard
on
the
promise,
so
all
futures
that
came
out
of
that
promise
will
now
be
considered
is
to
spare
me
so
that's
that
last
line
at
the
bottom
so
discard
actually
completes
the
future.
So
a
future
starts
in
some
state
pending
and
then
it
gets
completed
by
by
transitioning
to
what's
Daisy.
B
It
gets
completed
by
transitioning
to
ready,
by
transitioning,
to
failed
or
by
transitioning,
to
discarded
those
eternal
States
once
the
transitions,
those
states,
the
future
will
never
will
never
change.
After
that,
you
know
it's
completed
bang,
so
so
two
sides
to
discard
the
one
side
to
discard
is
a
request
for,
and
the
other
side
to
discard
is
actually
saying
that
the
computation
has
been
discarded.
I
eat
completing
the
future,
which
is
going
to
start
them
on
the
promise,
so
make
sense.
Okay,
so
a
slide
that
I
don't
have
in
here.
That
would
be
super.
B
B
So
this
is
so.
This
is
basically
this,
this
code
that
I
just
put
in
there
that's
how
you
could
attempt
to
do
a
discard
if
somebody
requested
it
of
you,
that's
an
expense.
So
if
you
nobody
puts
that
code
in
your
code
will
never
be
cancelable,
you've
got
to
promise
nothing's
ever
going
to
need
you
to
cancel.
You
actually
have
to
attempt
to
discard
by,
like
we're,
gonna
call
back
into
a
non
discard
all
back,
hoping
to
try
to
do
something.
Stop
it.
B
Okay,
now,
there's
many
different
things
in
the
process
that
by
defaults
are
already
canceled.
They
can
delete,
discard
and
so
oftentimes.
You
don't
need
to
ever
do
this
because
you're
calling
code
that
is
discardable
and
the
discards
will
just
propagate
which
we'll
talk
about
in
just
a
second,
but
if
you
were
doing
something
that
is
not
calling
something
else
that
is
discardable
and
you
want
your
code
to
be
discernible.
B
So
this
future
has
a
discard,
but
it's
ready
so
again
how
many
the
request
for
a
cancellation
on
a
future
does
not
mean
that
that
future
always
will
be
cancelled.
It
just
means
that
there's
been
a
request
for
it,
but
the
future
can
still
be
satisfied.
Make
sense
yeah,
please
just
jump
in
and
ask
questions
if
you
have
questions
I
kind
of
kind
of
a
lot
of
slide,
slides
and
we're
gonna
get
to
the
meeting
stuff
later.
C
B
So
this
is
where
we
start
to
get
from
some
of
the
meat.
So
what
is
the
semantics
of
discarding
with
respect
to
future?
Then?
Okay,
so
imagine
the
same.
Kokoda
head
above
or
I
have
a
promise,
promise
and
I
have
the
foo
function
defined
above,
which
is
just
returning
the
promise
of
stuff
future
so
now,
I'm,
actually
I'm
doing
I'm
calling
foo,
but
on
foo
I'm
doing
it
down,
then,
where
I'm
trying
to
take
the
value
of
the
int
and
then
stringify
it
and
return
it
back.
Okay.
B
So
now,
when
I
call
it
this
card
on
the
future
that
I
get
back
at
the
expected
future
has
a
discard,
and
the
promise
from
earlier
from
above
also
has
a
discard,
because
the
discard
propagates
the
future
that
got
returned
from
the
dot,
then
propagates
the
discard
up
to
the
future
that
it,
but
it's
down
then
on
to
which
was
from
foo,
which
is
the
promise
okay.
So,
no
matter
how
many
bends
I
have.
B
So
any
sense,
usually
okay,
so
the
reason
why
this
is
valuable
is
because
oftentimes
we'll
write
code
like
this
now
foo
could
be
the
saying
that
is
hanging.
It
could
be
the
thing
that's
taking
forever.
We
might
have
some
timeout
or
something
else
at
some
point
where
eventually
we're
like
this
whole
thing,
you're
trying
to
do,
let's
call
it.
It's
called
the
function
is
like
paint
bike
shed
right.
That's
what
we're
trying
to
do
to
paint
the
bike
shed.
B
I
have
to
go
collect
the
paint
I
have
to
buy
the
paintbrushes
I
gotta
open
the
paint
stir
it
I
gotta,
you
know
start
painting.
Maybe
the
very
first
thing
by
the
paint
is
the
really
expensive
thing.
It's
the
things
taken
forever.
So,
when
I
discard
paint
a
bike
shed
I
want
to
propagate
that
discard
all
the
way
up
to
the
very
first
thing,
which
was
go
by
the
paint,
because
I
want
to
stop
fast.
F
G
Look
at
Cole
and
on
the
way
they
handle
cancellation
is
by
passing
objects.
You
order
subsequent
homes,
calendars,
you
have
multiple
stages,
you
pass
the
same.
Artists
use
multiple
stages
and
there
are
everything
out
extremely
check
whether
you
have
cancelled
signal
on
that
out
there
or
not.
They
call
it
context,
but
that's
helpful
to
keep
the
hand
up
I,
don't
think
we
have
that.
You
know.
F
B
F
Okay
boy,
it
has
me
I
mean
I
over
promise
and
then
I
do
they
promise
stuff
futures
that
then
then
this
French
one
promised
a
future
done.
Then
then,
the
Miss
Prince
to
by
two
months
and
I
do
discard
from
first
on.
You
eventually
discard
the
promise
and
say
the
pond
is
part
of
us
ourselves
and
then
pays
even
discuss
late,
so
in
the
French
to.
Finally,
we
will
see
that
it
is
this
army.
You
know
that
baby
fuchsia
right.
H
A
F
B
I
think
that's
the
tricky
case,
as
the
bug
can
be
recently
run
into
and
problem
chance
to
talk
about
that
at
the
end
of
the
session.
Oh
no.
These
are
exactly
good
questions
to
ask
I
mean
I.
What
do
you
think
was
critical,
though,
is
that
if,
through
one
path
you
stay
discard,
you
say,
cancel
this
and
then
that
thing
at
the
very
top
says:
okay,
I'm
canceled,
anybody
else.
That
depends
on
that.
First
thing:
they
have
to
go:
cancel
yeah,
okay,
so
all
right
so
right.
B
So,
what's
important
here
is
okay,
so
to
know
the
better
example:
if
I
choose
to
discard
the
promise,
for
example,
let's
say
that
I
come
back
to
my
original
clue
code
and
I've
done
this,
and
what
this
does
is
on
the
discard.
It
just
starts
the
promise
right.
So
that's
this
line
right
here,
let's
say
I
choose
to
actually
discard
the
promise,
because
someone
has
requested
a
future
discard
I
would
expect
that
this
future
is
going
to
go
discarded
that
the
whole
thing
is
going
to
become
started.
B
However,
in
this
world,
when
I
said
the
future,
the
promise
because
I
discarded
the
future
here,
the
future
still
goes
discarded
so
what's
happening
here
so
what's
happening
here
is
the
implementation
of
then
is
seeing
that
somebody
has
requested
a
cancellation
and
it
is
cancelling
it
is
jumping
in
and
it
is
canceling
the
rest
of
the
execution
because
a
cancellation
has
been
requested,
and
so,
rather
than
executing
this
lambda,
it
is
saying
well
I,
don't
care
that
foo
is
completed.
Somebody
requested
that
I
cancel
I
can
discard
executing
the
next
thing.
G
Natural
I
feel
surprised
by
this
and
I.
Think
you're
surprised,
my
top
ten
or
I
can
process
feature
should
not
influence.
The
stay
of
the
future.
To
stay
on.
The
future
should
only
be
modified
by
the
promise
that
on
this
future,
rather
than
anything,
that's
inside
a
library
yeah,
so
so
I'm
looking
for
very
basically
like
when
I
program,
this
is
looking
for
environment
I,
mean
I,
mean
the
easiest.
If
I
mean,
if
we
can
provide
anywhere.
B
Yeah
I
mean
let
me
turn
that
around
for
a
second
though
I'm
not
actually
changing
your
state
I'm
changing
the
processes
prompts
the
states,
if
you
think
about
the
semantics,
and
then
she's
asked
me
to
do.
Is
you've
asked
me
to
execute
this
and
then
is
saying,
but
she
said
this
garden
to
me.
I
can
discard
I
know
how
to
discard.
I
can
not
execute
the
them
that
you
asked
me
to
do.
I'm,
okay,
I'm,
working
against
your
contract,
which
is
you
said,
run
this.
B
H
And
just
based
on
how
then
been
works,
I
basically
am
not
able
to
used
on
then,
if
I
want
to
keep
it
in
my
control,
so
I
mean
we've,
never
written
it.
I've
just
been
assuming
that
that
was
my
enduring
in
my
head.
Is
that,
like
the
user
of
the
processes
on
the
one
that
is
responsible
for
dealing
with
the
cancellations,
because
it's
sometimes
you
can't
cancel
on
me,
sometimes
cancellation
code
is
like
waiting.
Long
carry.
B
We
more
or
less
already
talked
about
this,
which
is
justice,
yeah
propagating
that
I'll,
throw
all
the
bends
and
then
the
trade-offs
we
need
to
think
about.
If
you
were
to
change
the
semantics
in
particular,
the
trade
up
we
need
to
think
about
is
how
we
handle,
and
it's
just
not
a
good
example-
that
in
can't
leave
a
better
example,
would
be
a.
B
Yeah,
okay,
so
two
really
quick
things:
I
wanted
to
mention
because
I
think
they're
they're
really
interesting
and
they
show
the
complexities
of
design
and
stuff
like
this
leave.
The
first
discard
to
the
body
or
the
iterative
loop
doesn't
disappear
on
its
own,
so
Luke
was
born
the
expectation
you
would
have
out
G,
and
we
discussed
this
quite
a
bit
when
I
was
first
creating
me
about
what
we
wanted
to
do
here
and
ultimately
decided
to
give
her
see
the
body
rather
than
do
kind
of
been
done.
B
So
just
say:
oh
well,
you
know
you've
asked
me
to
discard
other
than
calling
the
next
iteration
of
body
or
anything
else.
I
will
go
ahead
and
discard
it.
Okay,
wait
on
the
other
hands.
Does
it
fit
then
way
where
the
semantics
will
await?
Is
you
ask
me
to
await
for
things
if
you
discard
it
wait,
I,
say:
okay,
you're
no
longer
interested
in
awaiting
for
things
so
I'll
both
propagate
the
discard
to
all
the
futures,
because
you
no
longer
interested
in
them
as
well
as
I.
B
B
B
Because
I've
just
discarded
the
await
any
way
to
actually
stopped
I
know
that
I've
used
these
semantics
in
code,
multiple
places
I'm
not
sure
if
others
have
but
I've
used
the
semantics.
So
if
in
a
letter
and
a
weight
get
discarded
because
I
just
want
to
stop
weight,
you
know
whenever
I
was
waiting
on
and
then
do
other
things,
but
they
still
probably
back
right
to
those
future
discard
propagates.
But
what
I
mean?
Don't
even
wait
for
the
computer.
We
don't
need
a
way
to
go
the
actual
cancellation
to
occur
or
the
coefficient
over.
B
B
We
started
to
introduce
a
new,
primitive
called
undescribable,
and
the
basic
idea
of
on
discardable
is
basically
to
block
the
discard
propagation
so
now,
using
on
discardable
I'll
go
back
to
the
very
original
example.
You
review,
wrap
on
discard
around
food
and
still
discard
the
future
that
people
will
have
it
discard,
but
the
discard
will
not
propagate
so
promised
a
future
that
has
discarded,
doesn't
propagate
in
okay,
and
so
does
that
make
sense.
So
it's
that
it's
like
the
other
future,
except
to
describe
some
property.
Everything
else
is
exactly
the
same:
okay.
B
So
now,
how
does
this
work
or
something
like
with
future
dot
then?
So
we
can
continue
with
the
same
set
of
examples
from
poor,
weave
undescribable,
who
then
stringify
the
int.
Now,
if
I
discard
the
future,
the
future
has
the
discard.
The
promise,
of
course,
does
not
have
the
discard,
as
we
didn't
propagate
it
into
the
food,
but
when
I
set
the
promise,
the
future
still
goes
to
start
it
so
WTF.
B
B
B
G
B
B
B
And
so
it's
so
what
you're
really
trying
to
do
is
really
trying
to
say
once
some
event
occurs
later.
I
want
to
act
on
that
event
occurring,
but
I
don't
want
Street
this
event
as
occurring
as
being
part
of
the
action
of
what
I'm
doing
so.
This
is
where
on
discarded
will
becomes
really
valuable,
because
I
can
do
this
and
I
can
say
discarding
bags
should
not
discard
my
promised
future.
A
B
B
B
Where
undiscernible
becomes
useful,
regardless
of
the
then
chain
or
anything
else,
is
just
a
useful
property.
The
other
place
where
I'm
discardable
starts
to
become
useful,
useful
is,
is
with
a
weight,
as
sometimes
you
might
want
to
be,
like
no
I
actually
want
to
wait
for
the
stuff.
To
completely
finish,
if
someone
tries
to
discard
me,
don't
stop
waiting.
B
B
Alright,
so
so
yeah,
so
so
what
one
reasons
I
wanted
to
this
presentation
is
because
we
want
to
talk
about
change
the
semantics
of
future,
then
in
particular
changing
it
to
where,
if
there's
a
discard
on,
then
it
actually
will
it'll
still
like
in
a
little,
not
it'll,
still
execute.
Then
if
the
previous
function
has
gone
as
computed
and
it's
ready,
okay
and
there's
consequences
in
the
existing
code
base.
I
could
try
I
just
tried
to
change
the
semantics
and
run
all
the
maesters
tests
and
I
actually
get
check
builders
in
kinases
tests.
B
B
H
B
B
B
Well,
so
so
in
this
world,
if
you
were
to
change
the
semantics
of
future,
then
one
proposal
is
that
we
go
and
we
find
all
bends
in
the
codebase,
and
we
actually
do
this
and
we
put
this
discardable
around
from
right
in
front
of
all
the
vents.
So
we
get
the
same
semantics
as
as
the
current
code,
but
now
any
new
code
that
that
is
written
against
them
will
have
the
new
semantics
and
then
slowly
over
time
we
can
go
and
we
can
find
places
where,
like
no,
we
didn't
want
that
to
be
discardable.
B
B
It's
actually
not
as
I
thought,
so
that
would
be.
One
proposal
is
that
we
change
to
keep
the
semantics
of
then
we
introduced
discardable
and
we
go
only
find
those
locks,
and
you
guys
it's
very
explicit
and
to
them
is
discardable
whatever
the
line,
what
I'm
trying
to
do
and
then
we
find
them
and
people
over
timers
are
writing
code.
They
might
look
at
things
and
say
what
no
I
didn't
actually
want
that
to
be
discernible
I
wanted
that
thing
to
always
fall
through
and
they
could
remove
it
to
start
upon
get
this
semantics.
G
B
B
B
I've
I've
had
a
couple
of
this
a
couple
of
chunks
of
code
that
I've
written
recently
have
had
to
do
with
like
sockets
and
connections
and
it
could
go
abandoned
and
if
we
don't
actually
clean
up,
we
can
essentially
doom
the
master
if
we're
not
ok,
folks
on
the
Bandit
mix.
So
so,
what's
an
example
of
this
well
imagine
we
have
that
foo
function,
except
imagine
that
I
moves
the
process.
Sorry,
the
promise
into
the
through
function
itself.
What
is
this
thing
doing?
B
I
am
creating
this
promise
I'm
returning
the
future
from
this
promise
and
then
I'm
cleaning
up
the
promise,
which
effectively
means
that
the
future
can
never
be
completed.
It
will
stay
in
pending
forever,
because
this
promise
got
cleaned
cleaned
up,
there's
no
way
to
ever
ever
satisfy
on
the
future.
Okay.
So
this
awaits
gonna
wait
forever.
You
guys
might
have
seen
this
in
tests.
We
do
this
in
tests
all
the
time,
but
you
might
have
seen
it
in
tests.
B
Looking
like
this,
we
just
return
a
future
that
doesn't
have
an
initial
value
and
sometimes
in
the
test.
You'll
actually
see.
We
say
something
like
always
pending
because
like
we're
trying
to
create
the
illusion
of
like
something,
that's
always
gonna
be
pending
there,
you
go
that's
a
future,
that's
basically
always
pending,
but
here's
what
happened
like
this?
B
This
is
the
way
it
gets
dangerous
in
the
code
bases
when
you
create
a
promise
to
turn
this
okay,
so
this
is
something
we
wanted
to
solve
for
so
we
wanted
to
introduce
the
the
concepts
of
of
abandonment
and
so
basically,
a
new
call
back,
which
is
future.
That
is
abandoned,
which
tells
you
whether
or
not
the
future
hasn't
managed.
Now,
here's
in
another
call
back,
which
is
on
abandons,
which
is
kind
of
like
on
any
or
on
ready
or
anything
else
which
you
can
execute
if
the
future
goes,
those
two
mantlet,
those.
B
B
If
your
pending
and
promise
gets
cleaned
up
between
you,
the
structure
of
the
promise
to
do
that
in
the
structure,
the
promise
we
check
exactly
okay,
so
one
of
the
things
that's
really
important
to
realize
is
that
abandonment,
an
abandonment,
is
effectively
a
terminal
state
like
discarded
like
ready
and
like
fails.
However,
I
cannot
have
on
any
trigger
because
all
the
places
in
the
code
base
where
we
use
on
any
don't
know
that
potentially
it's
abandoned.
They
only
know
that
it's
discarded
failed
or
ready.
B
B
B
Whereas
on
abandoned
is
this
terminal
is
on
completed?
Okay,
so
that's
that's
abandonment
and
then
so,
in
addition
to
these
abandoned
and
on
abandons,
we
introduced
another
one
called
recover
and
the
way
recover
works
is
basically,
we
wanted
a
function
which
you
could
use
kind
of
like
a
been
to
handle
the
cases
where
something
has
failed
has
been
discarded
or
has
been
abandoned.
So
all
of
the
bad
cases.
If
you
will
so
you
know
all
the
cases
where
it's
basically
not
ready.
B
For
failed,
not
discarded
or
abandoned,
and
so
recover
is
for
all
of
them
all
the
bad
cases.
So
I
wanted
to
write
recover
when
I
added
repair,
but
I
also
knew
I
wanted
to
add
abandonment
and
I
didn't
want
to
introduce
recover
before
abandonment.
Was
there
because
then
recovery
wouldn't
handle
all
the
cases
and
all
the
places
for
people
are
using.
Recovery
will
be
broken,
so
that's
probably
having
kind
of
hurt
forever
and
who
know
maybe
we'll
find
some
other
thing
in
recovery
will
also
be
deprecated.
I'll.
B
This
is,
this
is
all
the
bad
cases.
This
is,
you
can
discard
it,
we
failed
or
you're
abandoned,
and
you
want
to
do
something
about
it,
and
so
you
know
here
you
go
if
who
so
here
you
go,
flew
obviously
is
gonna
get
abandoned,
so
this
is
going
to
get
executed
and
the
future
is
gonna
go
to
ready
and
it's
went
from
forty
to
now.
Here's
here's,
some
funniness
yeah.
G
G
B
B
Kill
on
it
on
anymore
over
time,
so
everything
will
be
functionally
change
yeah,
but
we're
not
there.
Yet.
This
is
just
this
stuff,
okay,
so
this
is
fun
though
so
so
this
is
just
recover,
but
guess
what
happens
when
you
mix
recover
and
then
okay?
So
so
so
this
is.
This
is
so
I
pulled
the
promise
back
out
so
that
I
couldn't
I
could
make
this
be
really
explicit.
Okay,
I
pulled
the
promise
back
out,
so
food
just
returns
the
future,
so
I
called
foo.
B
B
Okay,
so
the
discard
of
the
promise
caused
the
recover
to
execute
which
caused
dependence
thanks
s
now
watch
what
happens,
though,
if
I
first
discard
the
future
same
code,
so
now
I
discard
the
future.
First
then
discard
the
promise
recover
execute
because
the
futures
been
discarded,
but
now
the
ven
doesn't
execute
because
of
the
same
then
discard
stuff
that
we're
talking
about
earlier
and
the
whole
thing
goes
to
discarded.
B
So
right
now,
if
you
use
recover,
it
needs
to
be
at
the
end
of
your
chain
clue
unless
we
change
the
ven
semantics,
which
is
another
big
reason
why
I
want
to
change
the
nen
semantics
recover
can
only
be
used
at
the
bottom.
You
change,
if
someone's
doing
it
discard,
because,
while
recovers
gonna
get
executed,
nothing
else
will
I'll.
B
B
B
There's
places
where
you're
trying
to
not
have
discards,
propagate
and
then
there's
the
open
question
which
love
to
discuss
with
other
people
as
well
about
what
we
want
to
do
about
that
then
semantics
and
whether
or
not
we
want
to
do
this
and
we
want
to
go,
find
all
those
places
and
turn
them
into
them.
We
started
off.
G
B
What
what
about
it
wait?
What
if
we
think
of
a
weight
that
was
harder
because
I
personally
know
places
hide
users
in
the
coast
where
I
want
the
await
semantics.
I
want
the
the
net.
Now
you
see
recover
so
I
want
the
let
this
start
propagate
then
do
the
recover
and
then
don't
let
anybody
discard
it
again.
Then.
Finally,
wait
forever.
So
it's
like
I
want
I
could.
H
B
F
B
Does
propagates?
Okay,
great
question?
Oh
that's
the
most
that's
the
most
complicated
part
of
abandonment
is,
is
how
to
properly
do
that
propagation
through
associates
and
everything
else
so
I'm.
Sorry,
I
didn't
put
that
in
the
slides.
I
should
have
mentioned
that
but
abandoned
propagates.
So
if
I
am
I'm
on
a
bin
on
the
bed
on
the
bed
and
the
topmost
one
goes
abandons.
F
B
G
B
B
A
So
so
this
cards
like
what
the
scar
actually
means,
if
I
get
the
sense,
that
the
curse
and
I
thinks
have
this
notion
of
action
where,
like
as
as
the
person
who
is
older,
whose
future
they
can
say,
like
performer
cancellation
kind
of
as
opposed
to
I,
feel
like
what
I
made
up
I'm.
So
personal
I
never
knew
this
guy,
but
if
I
were
to
say
it
I
feel
like
what
I
wouldn't
want
to
say
is
that
all
I
call
up
I
feel
like
all
I
should
be
saying,
is
a
more
passive
statement.
Oh,
like.
A
F
A
Can
do
whatever
you
want
with
the
fact
that
I
mean
maybe
maybe
I'm,
not
the
only
person
who's
looking
at
it?
So
maybe
you
don't
do
anything,
but
if
I
am
the
only
one
I
was
looking
at
it
and
I'm
telling
you
that
I'm
the
last
one
and
I'm
going.
Do
you
stopping
me,
but
it
feels
it
feels
like
this
should
be
a
less
strong,
seeing
yeah
yeah.
B
B
I
discard
is
even
stronger.
It's
like
somebody
has
actively
told
me
to
stop
doing
this
and
if
I
can
get
you
to
stop
doing
it,
that
would
be
good
because
I
don't
want
you
to
do
it.
You
know
maybe
you're,
making
an
update,
cheating
database
and
no
just
kidding
I.
Don't
want
you
to
make
that
up
there
to
the
bigger
things.
B
B
Because
case
in
point,
be
accepting
of
a
web
server,
be
something
for
the
web
server
I'm,
actually
I
shut
that
thing
down.
There
could
be
many
people
are
listening
for.
You
know
stuff
to
come
out
of
that
web
server
and
I
actually
want
to
stay.
Hey
it's
time
to
shut
this
thing
down,
so
I
will
stop
the
web
server.
So
I'd
like
to
discard
was
actually
a
little
bit.
B
Turn
it
would
be
better,
everybody
would
have
to
implement
but
walk
away
and
have
to
control
the
codes
everybody
walks
away.
So
then
the
except
who
could
say
well,
I,
guess
no
one's
listening,
so
I'll
shut
down,
but
maybe
that's
not
the
semantics
it
wants.
Maybe
it's
a
night
well
I'll.
Just
keep
debating.
A
A
Yes,
well,
I
mean
yeah.
Well,
are
you
see
what
I'm
saying
is
like?
It
almost
sounds
like
there's
these
to
you
something
Oh
teacher
with
ownership
and,
of
course,
when
you
have
three
copies
of
feature
they're
effectively
like
one
doesn't
have
an
order,
trip
ID
doesn't
so
like.
What's
like,
they
should
be
like
some
future
was
implied
ownership.
That
can
do
the
starter.
That
can,
you
know,
affect
the
other
guys
yeah
kind
of
like
kind
of
look
or
your
members.