►
A
B
B
B
A
A
In
so
this
is
guaranteed
by
the
format,
but
the
format
is
addict
right
now.
So
that's
unfortunate
so
we'll
have
to
do
this
later.
Change
this
dot.
B
A
A
A
A
A
Okay,
we
want
it
true,
okay,
so
now
what
do
we
have
to
take
care
of
right?
So
we
have
to
take
care
of
the
expansion,
because
those
operations
currently
don't
see
expansion.
So
we
need
to
modify.
A
Okay,
so
we
can
remove
these
functions
for
now.
Let's
just
keep
them
here
all
right.
Let's
see
so,
let's
see
this
okay,
so
expand
equals
union.
Okay.
So
let's,
let's
do
that
all
right
get
this
status,
all
right,
it's
status
stage!
So
what
do
we
have
just
that
expand
equals
union?
Okay.
So
let's
just
commit
that.
A
Off
to
auto
death
or
auto
def
yeah
expansion.
A
Along
with
outputs,
okay
expansion
for
output
all
right
great
and
then
that's
what
we're
going
to
implement
next
so
hp?
Okay!
So
let's
see
what's
here?
Okay,
so
let's
just
do
this
static
method,
one
by
itself,
because
that's
a
big
enough
patch
and
then
let's
not
do
this.
A
A
Community
standards
alice
cli,
please
contribute
recommended
community
standards,
make
methods
static.
A
So
we're
purposefully
separating
this,
because
this
is
a
different
data
flow
and
the
other
one
is
an
overlap.
Okay,
so,
oh,
I
almost
did
the
a
on
this.
Okay,
let's
see
what
we
have
left
right
so
now
that
is
much
cleaner
right.
So
now
we
have
the
overlay
by
itself.
Okay
and
the
overlay
users
expand
okay
and
the
overlay
triggers
the
upstream,
because
it's
going
to
do
the
expansion
in
a
second,
okay,
great,
so
status.
A
A
You
know
so
this
is
our
in
progressive
youtube
in
progress.
Debugging
overlay
execution.
A
A
Let's
look
at
this,
so
I
was
also
thinking
that
this
perhaps
the
system
context
perhaps
provides.
A
A
A
Yeah,
like
simply
doctrines
with
usage,
so
let
me
show
that
basically.
A
We
should
be
able
to
so
this
way
that
we're
going
about
this,
where
we're
writing
the
tutorial
right,
so
she
should
be
following
the
same
process.
You
know
sort
of
we're
going
to
give
her
because
she
she
we're
expecting
alice
to
be
able
to
do
eventually
what
I'm
doing
right
now
right,
and
so
you
know
this
is
all
building
to
that
and.
A
A
A
A
Let's
please
contribute
recommended
community
standards.
Okay,
so.
A
A
A
And
let's
play
it
out
from
the
terminal
right
so
that
we
can
capture
what
is
the
full
description
of
state
right,
the
full
transformation
of
state
that
we
want
to
see?
Okay
and
we're
going
to
use
this
to
build
up
this
chain
of
system
context
right,
so
that
we're
going
to
help
alice,
build
an
understanding,
because
we
have
this
chain
of
system
context
which
completely
describes
the
problem
space.
We're
going
to
be
able
to
build
this.
A
A
You
know
by
guessing
that
the
contents
of
what
this
this
this
function
body
should
be
right,
so
we'll
just
we'll
eventually
have
a
world
where
we
we've
written.
So
many
of
these
that
we
just
have
that
and
just
simply
by
defining
the
you
know.
What
you
want
to
see
is
the
expected
system:
output
state
we'll
be
able
to
generate
the
code
that
gets
us
there
so
and
it's
because
we
have
the
data
types.
A
So,
and
and
we'll
have
deep,
instrumentation
right
and
so
we'll
be
able
to
do
this
correlation
to
understand
what's
related
and
then
alice
will
then
have
that
understanding
right
so
that
she
can
understand.
Here's
how
I
affect
the
environment
around
me
right,
there's,
here's!
These
are
the
way.
This
is
the
way
she
interacts
with
the
world
and
and
we
need
to
document
thoroughly
so
that
she
understands
it.
A
Okay,
so
and
also
because
the
idea
of
communication
witness
so
is
something
that
is
just
human,
understandable
and
she
understands
as
well
and
okay,
so,
okay,
jesus,
okay,
so
alice,
please
contribute
recommended
community
standards.
Okay,
so
let's
go
do
this,
so
let's
do
this.
A
A
Dude,
so
we
want
to
play
with
for
this
tutorial,
a
ghost
that
goes,
the
shellfire
ghost
chopper
ghost.
This
is
where
we're
going
to
you
know,
jump
into
recording
the
shell
and
stuff
so.
A
Okay,
so
she
has
your
list:
okay,
because
I'm
trying
to
say
we
said
we're
gonna
turn
these
things
into
rst
and
python
notebook
files-
and
I'm
like-
should
I
just
do
this
now,
but
this.
A
A
We're
gonna
prefix
everything
that
we
submit
with
or
suffix
everything
that
we
submit
with
alice
in
parentheses.
That
way,
we
know
it's
it's
from
pronouns
immediately
by
looking
at
any
issue
right,
so
we
can
see
if
she
just
created
any
issues.
A
A
A
A
A
A
A
So
then
we
need
to
get
a
repo
set
in
the
environment
variables
so
and
we
should
be
escaping
it
like
that.
B
A
A
Just
to
get
help
related
once
I'm
splitting
it
out
now.
I
know
I
wasn't
supposed
to
do
that,
but
I'm
doing
it
all
right.
Okay,
so
please
contribute
recommend
any
standards.
A
B
A
A
B
A
Am
I
on
youtube,
I'm
on
youtube,
yay,
okay,
so
this
one
is
a
really.
This
is
quite
the
split
episode
we're
splitting
we're
across
two.
So
this
is
this
is
speaking
of
relative
time,
so
we're
working
within
two
trains
of
thought
at
the
same
time,
right
so
we're
playing
with
the
ergonomics,
we're
in
architect
analyst
and
we're
also
doing
the
execution
we're
in
coach
alice
right,
okay.
A
So,
but
this
one
falls
a
little
bit
more
into
the
ergonomics,
because
we
pick
more
straight
into
it
right,
but
we're
clearly
doing
overlay
on
overlay
on
overlay
right
now,
so
we're
we're
playing
with
the
concepts.
A
And
then
we
would
say
related
related
issue.
You
know,
what's
the
what's
the
the
the
cleanest
way
to
slim
this
down
later,
but
we're
gonna
be
explicit
for
now
so
related
issue.
My
guess
is
muscles
will
end
up
being
just
for
loops
right,
but
we're
just
not
going
to
do
that
right
now,
so
related
issue.
A
All
right,
so
we
create
the
meta
issue
and
the
meta
issue.
B
B
A
Github
issues,
and
so
these
must
return
github
issues.
A
So
the
readme
issue
will
create
the
written
issue
and
we
basically
say
you
know,
give
me
a
list
of
all
the
issues
right.
So
we
want.
Is
there
a
way
to
get
an
automatic
type
conversion
on
that
when
we
do
an
auto
flow?
Maybe.
A
Okay,
so
yeah
we're.
This
is
what
so,
it's
for
both
because
we're
maintaining
our
interfaces
right
now
right,
but
we're
going
to
we
don't.
We
won't
have
to
maintain
our
interfaces
like
this
in
this
verbose
form
forever.
We're
just
doing
this
for
now,
because
we
don't
have
all
the
time
in
the
world
to
figure
out
what
the
right
pattern
is
right
now
to
do
auto
generation,
but
there
is
a
right
pattern
and
we
will
find
it
so
or
help
her,
but
we're
just
so
I'm
just
I
don't
know.
B
A
And
then
this
is
where
we
open
the
one.
So
if
these
are
all
none,
okay,
so
basically,
if.
B
A
See
so
basically,
what
do
we
want
to
say
if
you
have?
A
A
Right,
so
what
are
we
doing
here?
Okay,
so
let's
pass
a
repo.
A
And
this
is
why
we're
doing
it
this
way
you
can
see
now
we
can
just
do
very
simple
testing
of
this
okay,
so.
A
A
A
I
know
it's
down
here
somewhere
here.
It
is
all
right
so
here
in
the
contribute
cli,
where
we're
in
the
middle
of
making
this
this
little
unit
test
right
where
we
converted
the
one
to
the
other.
We
run
the
flow,
and
that's
supposed
to
be
that
right.
So
so
this
is
the
same
test
right,
we've
just
converted
this,
what
was
being
called
by
instantial?
We
just
got
instantiated
in
ad
hoc.
A
We
just
instantiated
an
instance
of
the
test
based
class,
and
then
I
called
this
sort
of
equal
method
so
that
we
could
just
get
that
nice
little
error
logging
without
actually
instantiating
a
test
place
test
case
class
because
we're
running
a
cli
command
right.
So,
okay,
so
we're
just
now
going
to
do
that
within
this,
which
is
a
static
method
which
should
take
just
this
static
data
here,
and
so
this
way
we
can
really
easily
test
that.
A
So
this
meta
issue
body.
Basically,
we
can
really
easily
test
that
this
will
give
us
the
right
format
for
the
body
and
then
we'll
create
we'll
create
that
meta
issue
based
off
of
the
meta
issue,
body
right
and
now
we'll
actually
do
the
interaction
with
github,
and
so
you
could
potentially
have,
for
example
like
here.
What
we
could
do
is
we
could
have
this
say,
meta
issue
body
rate,
and
it's
not
so
we
could
potentially
have
this
be
exact
instead
of
test
rate,
and
then
we.
A
Issue
body,
okay
here
and
then
this
comes
from.
A
A
A
A
All
right
so
github
repo
url
issue
create.
B
B
A
Okay,
so
the
body
is
dash
dash
body,
okay,
so
we're
just
body
okay.
So
this
is
how
we
create
the
issue
right.
So
we
say
this
is
exact,
and
so
then
we'd
make
the
type
meta
issue
right,
okay,
and
so
now
what
we
should
probably
do
is
I
wish
we
could
class
scope
the
definitions
of
these
new
types.
That
would
be
really
nice
if
we
could
class
scope
the
definitions
of
the
new
types.
A
A
This
overlay,
so
this
overlay,
this
pr
overlay,
knows
about
the
readme
or
the
the
issue
overlay,
but
it
doesn't
necessarily
know
that
you
know
that
yeah.
So
he
knows
about
the
the
issue
overlay
and
so
yeah.
So
it
only
really
it's
going
to
take
this,
though,
if
it's
there
right,
because
but
there's
a
default.
This
is
a
default
operation
that
defaults
to
none
right.
A
So
if,
if
that
definition
does
exist,
I.e
the
github
issue
overlay
is
applied,
then
the
polar
plus
overlay,
if
also
installed
or
I'm
also
active,
will
also
be
receiving
the
related
issue
of
the
readme
pr.
If
the
readme
pr
method
here
will
will
activate
what
will
have
a
related
issue.
If,
if
that,
if
that
github
issue
overlay
is
active
right,
so
actually
so
this
one
should
be
required
here,
though,
you
could
use
it
that
way.
A
Okay,
because
we
do
need
an
issue
if
we're
going
to
open
a
pr
alice,
doesn't
do
no,
no
issue,
no
pr-
and
that's
just
we're
just
going
to
say
that
okay,
so
all
right.
So
let's
see,
let's
just
remove
this
okay,
so.
A
A
A
And
this
would
be
community
standards.
A
A
A
A
Okay,
so
that
is,
please
contribute
community
standards.
Dot
read
me
branch,
okay,
so
if
we
say
alice,
please
contribute
recommended
community
standards
and
there's
a
need
to
commit
contribute.
A
readme,
then
alice
is
going
to
contribute.
Then
she's
going
to
generate
a
readme
branch
within
this
recommended
community
standards
flow.
Okay,
so,
and
so
that's
gonna
go
in
here
right
so
as
readme,
so
we'll
have
another
one.
That's
what
has
read
me,
which
is
contribute.
A
Read
me.
Okay,
so
what's
contribute
read
me
going
to
do
right
so
contribute
read,
me
is
going
to
say
readme
contents,
which
is
going
to
be
a
new
type
right.
So
of
course,.
A
A
All
right,
so
that's
a
stir
new
type,
so
read
me
content,
okay,
right
and
so
now,
assuming
we
can't
do
that.
We
have
to
do
this
forward
rough
stuff.
This
is
going
to
be
a
lot
of
we're
about
a
lot
of
stuff
here,
so
assuming
that
we're
gonna
have
this
forward
rest
stuff.
Okay,
so
then,
basically
reading
content,
okay,
and
so
then
this
would
be
read
me.
A
A
Okay,
because
how
do
you
contribute
it
when
you're
contributing
to
a
git
repo,
you
create
a
branch
right
and
then
what
you
do
with
that
branch?
That's
the
pull
request,
which
is
the
overlay
which
is
specific
to
github.
It's
how
you're
submitting
the
pull
request
right.
So
you
could
create
an
overlay
for
any
of
your
work
on
any
project
right
and
you
could
say
when
I'm
done
committing
my
code.
This
is
how
I
want
you
to
push
it
right.
So
this
means
that
you
no
longer
have
to
work
with
git
based
remotes.
A
You
can
work
with
arbitrary
remotes
which
store
the
history
of
your
repo
and
maybe
translate
to
and
from
git
okay,
so
like
the
did
based
stuff,
so
we
can
have
basically
by
importing
by
by
serializing
to
the
id
based
format.
What
we're
going
to
end
up
with
with
is
a
mirror
image
of
all
git
repo
history
or
what
will
be
now
herstory,
because
it's
all
alice's
right
because
alice
is
this.
You
know
about
which
is
gonna.
A
Data
stream
and
the
rest
of
them,
so
it
sounds,
sounds
ridiculous,
but
this
is
what
we're
doing
so.
A
A
Okay,
read
me:
branch:
okay,
read
me
contents,
all
right,
so
we're
just
going
to
cut
out
all
the
rest
of
this
right
now
as
readme
can
truly
read
me:
okay,
so
we're
going
to
create
a
little
blank
repo
and
we're
going
to
do
this
in
the
blank
repo
okay.
So.
B
A
It
has
read
me
and
then
you
could
just
say
okay,
so
this
is
as
readme
and
you
define
it.
With
effect,
I
check
like
that,
which
means
that
you'll
look
into
the
same
class
and
I'll
say
has
read
me
so
it
says,
grab
the
return
value
of
that.
A
B
A
A
A
A
Whatever
works,
I
love
it
good
check
out.
A
So
this
this
method,
this
operation,
ads
okay,
so
profile
not
gonna
check
while
pass
free.
A
B
A
So
this
could
go
and
we're
not
going
to
do
all
this
right
now
from
executing
this.
I
just
want
to
see.