►
Description
A
All
right,
yeehaw,
let's
go
so
all
right,
all
right,
okay!
So
what
are
we
doing?
So?
I
realized
you
know.
Okay,
we
gotta
get.
I
gotta,
I
gotta
get
the
the
stuff
in
a
format,
it's
a
little
more
consumable,
so
we're
gonna
go
ahead
and
create
branch
alice
from
main
here
and
we're
going
to
change
the
base
branch
on
this
pull
request.
A
B
B
A
A
A
A
A
B
B
A
B
A
B
A
A
Find
doc's
arch
alice
all
right
great,
so
we
got
all
whoa
whoa
whoa,
whoa
whoa.
Why
aren't
those
in
order?
Okay,
sorted,
sort,
okay,
great,
okay,
yeah,
so
sort
them
all
okay.
So
let's
do
dash
type
f,
okay,
so
here's
all
our
to
all
our
all,
our
all
our
docs.
So
far
right,
so
let
us
go
through
and
what
should
we
do
here?
A
A
A
A
A
So
let's
just
do
dash
dash
okay
and
let's
actually
throw
the
dash
dash.
Let's
give
that
a
couple
new
lines
as
well:
okay,
so
all
right!
So
now
we
have
our
our
our
horizontal
rule
and
we
have
our
files
and
they're
nicely
newline
delimited
okay.
So
what
we
can
do
from
here
is
we
can
yeah
we'll
take
these
and
let's
see,
let's
do
pattern
text,
let's
just
say.
B
A
A
So
now
we
only
get
the
ones
that
start
with
a
pound
sign
which
is
much
easier
for
us
to
work
with
here,
because
I
think
this
is
most
of
the
yeah
okay,
so
this
is
most
of
the
stuff
okay.
So
let's
actually
take
this
and
say:
okay,
so
let's
take
this
and
convert
it
into.
Let's
see,
let's
look
at
the
titles
so.
A
A
Turtles
all
the
way
down
down
the
dependency,
rabbit
hole
again:
architecting,
alice
forward,
open
architecture,
initial
working
group
meeting
alice
our
open
source
guide,
starting
a
new
project
with
us,
traveler
of
the
edge
peace
at
last
she's
arriving
when
shelfer
ghosts,
our
strategic
principles
guide
our
game
plan.
Okay,
so,
let's
see
so
I
think
that's
pretty
good.
I
think
we'll
we'll
shuffle
that
around.
So
that's,
basically
what
we
want.
So,
let's
filter
out
the
ones
that
we
don't
like.
A
Okay,
so
basically
anything
that
doesn't
start
with
volume
right
so
manifest
schema.
I've
got
a
note
here.
It
says:
refactor,
discussion
into
adrs
and
tutorials
idr's
is
manifest,
schema,
slash
the
manifest
one
and
then
tutorials
is
the
rest
of
it
right.
So
I'm
gonna
split
it.
What
we're
gonna
do
is
we're
going
to.
A
A
A
B
A
B
A
A
File
name
doesn't
get
used,
okay,
not
in
dump
discussion,
but
we're
using
it
now
because
we're
taking
dump
discussion
and
then
we're
doing
this.
Okay.
So
you
know
we
could
just
do
this
in
dump
discussion
yeah.
We
could
just
say
these:
are
content
edits,
okay,
so
dump
discussion,
okay,
I'll,
put
mark
down
okay!
So
let's
just
grab,
let's
just
go:
grab
them
introduction
contest,
good
crap.
A
A
B
B
A
A
B
B
B
A
A
A
So
what
I
do
is
is
what
I've
been
doing
is.
Is
you
know
we
we
we
have
a
session
and
or
I
work
right
and
then
I
go
for
a
walk
and
I
take
notes
and
then
basically
you
know
flipping
back
and
forth
across
context.
You
know
you,
don't
you
don't
context,
switch
or
or
you
you
sort
it
you
take
it.
You
take.
A
A
You
want
something
done,
okay,
so
I
got
on
all
about
the
merge
command
and
then
I
was
like
okay,
you
want
something
done.
You
write
an
operation,
okay,
so
to
implement
second
party,
you
write
an
operation
which
takes
the
loaded,
dict
form
of
a
pipeline
emo
file.
For
instance,
it
should
output,
a
data
flow
specific
to
each
dick's
context.
A
Contents,
the
pipeline
converted
to
a
data
flow
okay.
So,
just
just
basically
just
do
it
just
just
take
an
operation
and
just
write
an
operation.
Have
it
take
a
loaded
form
of
a
yaml
file
right
so
just
a
dictionary
and
make
an
output
a
data
flow.
That's
descriptive
of
how
you
would
run
that
pipeline
right,
so
we're
going
to
do
a
github
actions
workflow,
because
we
know
those
workflows
that
we
have
exist
and
we
can
run
them
via
the
ssh
or
kubernetes.
A
A
A
Okay,
let
me
finish
this
okay,
so
so
let
me
just
say
the
rest
of
this
and
then
I'll
get
back
to
creating
this
markdown
files
or
renaming
them
so,
okay,
so
all
right,
so
basically
just
yeah
load.
The
existing
flows
into
data
flows
now
create
the
data
flow,
which
is
the
base
flow,
which
we
can
apply
the
previous
flows
to
as
overlays
okay.
So.
A
Okay,
so
load
the
flow
okay.
So
what
this
is
saying
is
basically,
we
need
to
figure
out
how
to
split
out
those
those.
What
will
what
we'll
end
up
with
is
in
that
parsing
of
the
the
flow
we'll
end
up
with
we'll
we'll
end
up
with
basically
like
a
bunch
of
the
seed
inputs
will
be
the
matrix
and,
and
that
might
be
nested,
and
so
what
we'll
need
to
do
for
each
plug-in
right?
We
have
another
seed
input
which
starts
another
context
for
that
plug-in.
A
Actually
it
doesn't
start
another
context
for
that
actually
yeah.
It
starts
at
context
for
the
github
actions
job.
You
start
a
context
for
each
set
for
each
input
set,
so
each
plug-in
permutation
right.
So
we
already
do
the
same
sort
of
thing
so
we'll
basically
just
add
each
one
as
an
input
and
then
it'll
end
up
executing
all
the
permutations
so
but
but
the
trick,
the
the
thing
is
that
we'll
need
to
then
go
through.
A
What
that
says
is
basically
so
so
so
see
see
what
look
at
look
at
the
the
flow
which
we
just
wrote,
the
operation
to
where
we
convert
and
it's
a
whole
flow
and
now
split
out
a
base
flow
cut
out,
some
of
those
seed
inputs
and
stuff
that
and
the
and
this
and
the
other
operations
in
there
and
the
subflows
that
might
be
that
are
for
the
the
the
plug-in
validation
right
that
are
maybe
plug-in
validation.
Specific.
A
Actually,
I
don't
know
yeah
so
like
the
tutorials
and
stuff
right
and
the
other
operating
system.
So
so
we'll
split
those
out
well,
the
other
operating
systems
we're
just
going
to
drop
for
now,
but,
let's
see
so
create
data
flow,
which
is
basically
where
to
apply
previous
flows
to
is
overlays.
This
is
the
common
ci
flow.
A
Actually,
I
think
the
other
yeah
we'll
basically
have
the
those
those
other
operating
systems
be
triggered
on
an
input,
and
then
we
won't
add
that
input
to
the
seed
okay.
So
this
is
the
common
ci
okay.
So
this
we
end
up
with
that
delta,
basically
between
the
ones
that
are
that
are
plug-in,
specific
or
tutorials
right
or
the
lint
right.
That's
not
the
plug-in
specifics
right
now,
because
we
get
into
that
later
right
now,
we're
gonna
still
call
dot.
A
Ci
run
sh
underneath
so,
but
basically
this
will
be
the
common
ci
flows
which,
which
is
shared
across
all
our
second
and
third
party,
plug-in
ecosystem,
and
so
then,
basically,
then,
I
have
a
note
about
the
overlay
process.
Is
the
shim
process
the
merge
of
the
installed
before
merge
is
applied
to
upstream?
It
is
analogous
because
this
is
where
context
specifics
are
figured
out
aka.
Where
are
we
in
org
mode?
A
Is
org
policy
active
aka
what
shim
plugins
are
available
and
what
next
phase
selection
and
what
next
phase
selection
and
and
arguments
should
be
passed.
It
is
analogous
to
this
in
this
way,
because
overlays
provide
both
both
stubs
for
discovery
of
executable
code
and
an
option-
those
those
op
amps
and
configs,
as
well
as
optional
seeds-
oh
sandbox,
as
well
as
optional
sandbox
execution
during
apply,
of
course
right
so
because
we
can
specify
operations.
So
first
go
and
clean
up,
alice,
doc:
okay,
yeah!
That's
what
we're
doing
right
now:
okay,
examples!
A
Oh
so,
then
yeah!
We
need
to
do
an
example
where
we
have
multiple
developers,
working,
writing
little
things
little
operations
and
they
both
take,
for
example,
that
aiohtp
client
session
and
then
we'll
show
how
transparently
all
of
the
you
know,
operations
use
that
aiohtp
client
session.
So
you
actually
see
value
out
of
that
shared
across
your
your
application,
so
that
shared
pool
so
base
institutional,
ops,
okay.
So
what
is
this
incorrect?
Shared
object,
use,
use,
actuate,
object
view
open,
based
in
differentiation
of
absence,
static
content
coming
from
ops.
A
Where
was
that
code
we
played
with
okay,
yeah,
oh
yeah
and
then
sahil.
So
the
question
and
answering
model
the
video
based
model
that
sahil
has
to
to
do
question
answering
so
so
there's
a
lot
of
stuff
that
we've
covered
about
the
dftml
code
base
in
here
and
so
in
this
series
of
engineering
logs
and
what
we
can
do
is
we
should
be
able
to.
Basically,
you
know
effectively
concatenate
all
the
transcripts
together
and
then
run
the
qa
model,
and
we
should
have
you
know
this.
A
Could
this
this
could
be
a
start
of
a
q
question
answering
model
for
alice
to
help
new
contributors
to
the
project,
because
hopefully,
she'll
she'll
have
some
of
the
stuff
in
the
notes,
basically
from
the
transcripts,
so
that
would
be
cool,
and
so
basically
you
know
we
need
a
version
so
alice.
Please
is
this,
is
all
this
is
wrong?
Now
I
realize
we
have
alice
please.
So
I
was
going
to
say
we
could
do
alice,
comma
and
alice
colon.
B
A
Let's
see
coach
us
yeah
coach,
alice,
yeah,
so
coach
house
would
be
a
good
one,
so
so
down
the
dependency
rabbit,
hole
again
I'll
start
opening.
So
our
open
source
guide,
maybe
we'll
just
say
our
open
source
guide
yeah.
So
so
so
you
downloaded
penn
state
rabbit
hole
again.
Our
open
source
guide
strategic
principle,
says
game
plan.
A
A
And
so
what
is
this?
This
is
reach.
This
is
about
the
fully
connected
development
model.
We're
basically
just
you
know,
recording
our
thoughts
and
then
making
them
accessible
to
the
other
developers
on
the
project
right.
So
this
is
this
is
and
then
alice
is
going
to
go
and
give
them
coaching.
So
this
is
so.
A
Asynchronous
learning
asynchronous
communication,
strategic,
open
source
guide,
game
plan,
strategic
principles,
game
plan,
I'm
like
is
there
a
theme
here,
I'm
trying
to
figure
out
if
there's
a
theme
and
I'm
trying
to
stick
with
it.
If
there
is
one
so
she's
arriving
away
in
a
shelf
for
a
girl
scout
traveler
on
the
edge.
So
this
is
all
conceptual
stuff
and
now
we're
getting
into
implementation.
So
this
is
implementation
alice
in
the
art
of
strategy
alice
in
the
strategy
of
art
alice
in
the
health
of
the
ecosystem.