►
Description
A
We've
taken
the
the
discussions
thread
which
we
were
working
in,
which
was
the
alice
thread
here
1369.,
and
so
this
was
the
original.
You
know
this
was
used.
This
used
to
be
the
the
improved
data
flow
docs
discussion,
which
you
can
see
got
migrated.
I
got
migrated
from
an
issue.
I
don't
know
where
that
information
is
now
yeah
converted
from
issue,
but
the
information's
gone.
But
there
is
an
issue
where
this
used
to
live
for
the
even
older
version
of
this.
A
A
You
know,
what
does
our
mental
model
look
like
and
a
lot
of
that
work
is
captured
within
the
thread
here
and
is
not
yet
exported
to
what
we've
done
for
for
june,
and
what
we've
done
for
june
is
at
the
bottom
of
thread.
So
here's
the
second
party
pull
quest,
so
this
all
started
when
we
went
and-
and
we
said
okay-
we
need
to
split
out
the
plugins
and
to
facilitate
this
second
party
setup.
A
A
So,
and
so
this
is
what
this
pr
now
covers.
So
this
covers
a
lot
of
different
code
and
then
a
lot
of
just
the
discussion
stuff
that
was
exported,
so
the
the
the
pieces
of
this
that
are,
you
know,
of
interest
and
and
to
be
contributed
to.
So
please
pull
request
the
alice
branch
or
please,
you
know
comment
directly
in
here
and
so
the
these
are
sort
of
the
pieces
of
interest
and
there's
a
lot
of
other
code
in
there
that
that
I'm
gonna
clean
up
that
are
some.
A
You
know
functionality
related
stuff,
that's
just
been
sitting
around
in
the
same
branch
that
need
to
get
cleaned
up.
So
so
then,
okay,
so
what
do
we
got
so
yeah?
So
we
have
the
tutorial
itself
right.
So
this
is
where
you
know
we're
going
to
map
the
existing
work
streams
that
we've
identified
here.
As
far
as
chapters
that
we've
already
started
in
flight,
we're
going
to
try
to
map
this
over
the
next
one
to
two
years,
so
you
know
reach
out
get
involved.
A
If
you
want
to
propose
a
chapter,
you
know
propose
a
tutorial
and
then
we'll
figure
out
where,
where
we
can
fit
into
the
roadmap,
with
with
other
mentors
and
maintainers
to
work
with
you
on
that,
so
then
let's
see
so
yeah.
So
so
we
can,
you
know,
just
jump
right
into
these.
The
prefaces,
I
think,
let's
see
the
preface
is
yeah.
A
Can
either
add
it
either
add
in
either
place
place
right,
we'll
try
to
make
sure
that
that
it
it's
it's
deduplicated
so
and
just
make
sure
you
know
you
you,
you
give
us
enough
information
that
that
somebody
can
build
off
something
right
or
we'll
evolve
it.
We
we
just
you
know
all
brainstorming
is
good
right
now,
so
we
need
to
sort
of
flush
flush
this
out.
So,
okay,
let's
see
so
the
architect
analyst
volume
zero.
This
is
the
one
where
we're
you
know
figuring
out.
A
And
so,
if
we
can
all
collaborate,
you
know
to
define
a
spec
there
or
to
to
work
towards
a
spec.
You
know
and
perhaps
building
on
this,
this
next
piece,
which
is
the
manifest
adr
to
to
figure
out.
What
does
that
manifest?
Look
like
for
that
policy,
and
then
at
that
point
we
can
start.
You
know
we'll
start
like
we'll,
we'll
take
the
cv,
bend
tool,
existing
triage
mechanism
and
we'll
we'll
we'll
evolve,
that
into
this
policy.
A
Parser
and
and
everybody
can
have
their
own
and
do
different
stuff
off
of
it.
But
generally,
you
know
we'll
have
this
this,
this
policy
piece,
which
will
say
you
know
hey.
How
do
we
accept
cbes,
you
know
like
or
like
how
do
we
deal
with
upgrades
of
cves?
You
know
what
ones
just
pass
through
if
the
tests
pass.
You
know
like
what
what's
sort
of
our
general
pattern
of
like
how
do
we
deal
with
incoming
events
if
alice
is
maintaining
a
repo?
A
What's
the
policy
around
how
she
deals
with
incoming
events
right,
that's
sort
of
how
we
can
think
of
that,
and
then,
of
course
you
know
alice
is
the
the
fulfillment
of
the
of
the
software
supply
chain
on
demand
right
in
a
context
aware
fashion,
so
the
s-bomb
stuff
is
going
to
be
very
critical
in
figuring
out.
You
know
what
is
the
existing
stuff
stuff
that
we
need
to
fulfill
in
in
terms
of
delivery
if
that
asset
is
requested.
A
So,
let's
see
and
and
we're
looking
of
course,
so
we're
looking
at
analysis
of
existing
artifacts
right
via
things
like
cv,
eventual
and
then
we're
also
looking
at
the
definition
of
the
plug-ins
that
we're,
creating
and
and
producing
s
bombs
for
that
stuff
as
well,
right
and
and
making
that
all
the
same
thing,
which
is
the
open
architecture.
So
your
s-bomb
is
your
basically
your
s-pawn,
you,
you
take
your
open
architecture.
A
You
overlay
your
s-bomb,
you
get
a
running
application
right,
so
if
we
yeah
and
then
you
know,
here's
shows
some
stuff
that
we're
gonna
do
where
we're
gonna
get
into
you
know
throughout
modeling
and
debugging,
and
really
build
this
entity
alice
off
of
this
this.
This
coach
alice
first
set
of
tutorials
as
the
base
where
we
really
get
deep
into.
How
do
we
be
software
developers
right
and
what
is
the
the
thought
process
that
we
go
through
and
model
that
thought
process
in
analysis
code
and
in
her
overlays?
A
A
You
know
effective
strategies
for
controlling
one's
own
mind
and
then
through.
Creating
this
network
of
agents
and
and
detection
of
the
network
of
agents
of
who
controls
one's
own
mind.
We
can
develop
adapt
like
we
can
we'll
develop
adaptive
policies
to
modify
our
threat
model
to
these
more
strategic
threats
that
we
faced
in
this
hostile,
open
network
environment.
So
in
volume
four,
then
we're
going
to
go
into
okay.
So
now
we
have
so
we
have
all
right.
So
what
what
have
we
got
here?
At
this
point?
A
We've
got
our
plans
volume
zero.
This
is
what
we're
running.
This
is
like
our
running
thing,
where
we
sort
of
just
keep
going,
keep
adding
more
stuff.
It's
it's
if
it's
high
level
architecture
stuff,
so
it's
sort
of
a
volume
sort
of
knot
and
then
so
it's
sort
of
a
set
of
tutorials,
it's
sort
of
just
like
our
context.
Around
the
whole
thing
view
does
almost
like
an
adr
and
implementation
so
and-
and
so
when
we
move
so
so
this
is
yeah.
A
So
this
is
how
we've
built
her
architect
analysis,
coach,
alice.
This
is
alice
the
overlays
of
the
software
engineer,
the
software
architect
and
then
alice
in
the
art
of
strategy.
You
know
the
communication
overlays
allison's
strategy
of
art.
You
know
these
what
become
effectively
our
security
in
this
new
environment
in
this
new
threat
landscape
and
then
once
we
have
that
now
we're
like
okay,
so
we've
got,
we've
got
our
functionality.
Coach,
alice.
We've
got
our
communication
with
the
outside
world
volume,
two
alice
in
the
art
of
strategy.
A
How
does
she
produce
art?
How
does
she
interpret
art?
How
do
we
interact
with
her
in
that
way
volume?
Three?
Then
we
have
allison
the
strategy
of
art,
so
she's,
seeing
these
communications
that
she's
interacting
with
the
outside
world.
She
knows
how
to
do
her
job
and
she
knows
how
to
sort
of
like
respond
and
adapt
in
this
dynamic
way,
which
is
pursuant
to
her
pers,
which
is
always
in
pursuit
of
her
strategic
principles.
A
So
in
this
volume
allison
the
health
of
the
ecosystem,
you
know
alice
will
be
out
there
and
she
will
be
contributing
to
open
source
projects
right,
and
so
she
will
be
building
up
our
open
source
projects
because
we
don't
want
to
let
her
out
on
the
whole,
you
know
wide
world
yet.
So
this
is
our
dfml
ecosystem
and,
of
course,
anybody
else
who
wants
to
participate
in
in
our
little
tutorial
here,
so
so
so
in.
In
that
case,
we're
basically
just
gonna
monitor.
A
I
don't
know
we
need
the
this
one
out
more.
So,
but
this
is
basically
like
hey
this
is
this
is
right
before
number
five,
which
is
then
okay
now
alice
here
you
go
you're
going
out
into
the
world.
You
know
we
think
you're
pretty
much
you're
almost
there
and
then
at
that
point
you
know.
I
know
this
is
pretty
far
out
right.
This
is
probably
like
we're
looking
at
like
these
are
probably
a
year
each
right,
so
we're
probably
looking
five
years
out
now.
So
I
don't
know
this.
A
Would
you
know,
feel
free
to
propose
stuff?
And
this
is
you
know
what
it
should
look
like
in
the
real
world?
What
kind
of
stuff
do
we
have
to
deal
with
there?
We
want
to
make
sure
to
get
anything
and
everything
this
is.
You
know
ethical
considerations,
we're
thinking
about
like
we're,
teaching
a
real
human
right,
don't
think
of
her
as
a
machine.
Think
of
her
as
a
human
like.
What?
How
do
you
be
a
software
engineer,
a
software
architect
in
the
world
right
and
then
how
do
we?
A
You
know
debug
your
mind
like
a
machine
and
then
make
you
make
you
rolling,
which
is
volume
six
right
and
then
we
basically
go
in
and
we
say:
okay
you've
been
out
in
the
world
for
a
year
now.
How
do
we
fine
tune?
You
right
so
so
volume
five
is
more
of
like
okay,
like
hey.
This
is
a
different
environment.
You
know
it's
not
it's
not
a
sandbox
anymore
right.
Our
ecosystem
is
our
sandbox
volume.
Five
is,
is
you
know,
okay,
no,
more
sandbox
and
then
volume
six
is
okay.
A
Let's,
let's
we
were
in
firefighting
mode
for
a
year.
Let's
assume
this
is
how
these
things
go.
And
so
then
we
come
in
in
volume
six
and
we
start
to
say.
Okay,
now
we
recognize
okay,
we've
we've
taken
care
of
the
firefighting
mode
stuff.
Now,
let's
fine
tune
and
then
finally,
once
we
fine
tune,
then
she'll
be
rolling
and
we'll
all
be
we'll
all
be
rolling
through
whatever
whatever
the
other
side
of
this
is
and
she'll
tell
us
what
that
is
so
yeah.
A
So
please
pull
request
and
review
the
alice
branch
and
and
please
feel
free
to
comment
in
the
pr
or
or
reach
out
directly
but
yeah.
So
this
is
where
we're
at
for
june.
Basically,
so
what
what
to
expect
well
we'll
be
marching
towards
rfc
v2,
probably
sometime
around
the
end
of
december
we'd
like
to
see
you
know
the
rest
of
the
adrs
that
are
involved
in
this.
A
So
great,
I
think
that's
where
we're
at
so
the
ci.
The
ci
does
not
work
right
now,
so
the
the
demo
code
that
we've
been
working
on
that
does
work.
So
if
you
want
to
work
on
alice,
then
it
works
right,
but
the
next
thing
that
that
all
I'll
be
doing
is
I'll
be
trying
to
get
the
overlay
stuff
working
and
then
the
first
tutorial
for
the
overlay.
So
we
can
give
people
writing
overlays,
so
yeah
great
all
right!
Well,
thanks!
Everyone.