►
A
B
B
B
A
A
B
A
A
A
A
A
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
A
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
A
A
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
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
A
A
A
A
A
A
A
A
A
B
A
A
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
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.
B
B
A
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
B
A
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
A
A
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
A
A
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
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.