►
A
All
right
live
from
wonderland.
We
are
architecting
alice,
okay,
so
I
wanted
to
show
for
others
in
my
own
memory
here
how
I
got
this
working
with
our
webrtc,
because
I
got
a
friendly,
friendly
email
from
my
internet
service
provider
telling
me
that
I
used
1.2
terabytes
of
data
so
within
the
month
of
may.
So
I
realized,
then,
that
that
we
were
going
to
discord
and
back
so
problematic.
A
A
Okay,
all
right!
So
I've
got
another
window
here.
So
I've
got
I'm
using
this
webrtc
dash
video,
slash
room,
github
thing
and
they
have
a
dot,
heroku
app.com,
and
so
then
we
say
accept
on
the
other
machine
and
boom.
Here
I
am,
and
now
we
are
not
I
mean
I
can
I
mean,
look
how
much
faster
this
is.
This
is
insane
so
it's
great,
and
then
we
do
have
the
little
wichita
dings
here
in
the
bottom,
but
I
think
we
can
fork
this
project
if
we
wanted
to
so.
A
The
the
most
important
part,
though,
is
that
you
got
to
do
the
alt
tab
to
do
the
get
user
media
and-
and
you
know
this
seems
like
a
little
bit-
let's
be
honest-
that
seems
a
little
bit
hacky
so
may
or
may
not
be
around
for
us
in
the
future.
But
for
now
this
is
some
mechanism.
We
can
use
all
right,
let's
get
to
it.
So
what
are
we
doing
today?
Well
same
thing,
we
are
doing
yesterday
so
because
we
were
not
done.
I
tried
many,
a
webrtc
thing,
what
the
hell!
A
Okay,
so
main
point
of
recent
discovery
was
okay:
let's
just
work
through
this
okay,
so
we're
in
the
middle
of.
A
We're
in
the
middle
of
very
many
things
right
now,
but
and
we're
way
deep
in
the
stack,
but
so
I'm
not
going
to
do
an
overview
of
where
we're
at
suffice
it
to
say:
okay,
no,
I
am
going
to
do
an
overview
of
where
we're
at
okay.
So
where
are
we
rename
window
say
so
we're
teaching
alice
how
to
say
hello?
Why
are
we
teaching
us
how
to
say
hello?
Well,
I
think
it's
plenty
covered
in
the
last
video.
A
Basically,
this
is
our
basic
case
for
pr
response,
so
pull
request
response
for
static
analysis.
So
we
talked
about
time,
windows
and
yada
yada.
Basically,
this
is
our
simple
case
so
and
the
reason
why
we're
doing
this
is
because
we're
playing
with
the
system
context
we're
trying
to
understand
what
is
the
system
context?
You
know,
how
does
it
relate
to
input
objects?
How
does
it
relate
to
the
other
objects
within
our
our
current
code
base?
A
And
you
know
how
do
we
effectively
maintain
our
chains
of
system
context
via
their
links,
but
but
oops?
We
had
this
realization
that,
well
you
know
the
links
are
effectively
really.
We
need
to
rename
parents
to
links,
because
it's
not
really
parents,
it's
links,
and
maybe
their
parents,
maybe
they're,
not
it's
really
just
something
they're
associated
with
it's
basically
we're
turning
this
into
a
pdid
and
so
yeah.
Okay,.
A
And
we're
trying
to
make
callables
out
of
these
things,
so
we
had
some
handy-dandy
code
that
was
over
here,
which
basically
we
could
wrap
a
generator
or
we
could
wrap
co
routine.
We
could
wrap
an
async
function
or
whatever
we
can
wrap
up.
Basically,
we
had
this
wrapper
code.
That's
like
we
can
wrap
whatever
right,
okay.
Well
now
we
don't
necessarily
have
a
specific
thing.
A
We
have
this
data
flow,
okay,
the
system
context,
and
within
that
system
context
we,
you
know
we
may
want
to
use
it
very,
a
variety
of
different
ways
right
so.
A
Some
things
so,
for
example,
so,
for
example,
the
domain.
What
do
we
really
care
about
we
care
about,
like
so
thinking
about
this
as
communicating
with
alice
as
the
core
of
it
sort
of
simplifies
the
problem
space
right?
So
we
talk,
we
we
care
about
communicating
with
alice
right
if
we
can
communicate
with
alice.
If
we
can
communicate,
you
know
with
the
machine
in
this
shared
language,
we
can
do
anything
right.
This
is
the
hypothesis
so
to
that
effect,.
A
We're
going
to
iterate
over
her
thoughts
so,
and
so
this
is
basically
the
same
as
wonderland.
A
Wonderland
async
in
it,
or
maybe
just
wonderland,
async
right,
so
so
we
can
say
from
wonderland,
import,
alice
right
and
there
she
is.
So
what
is
alice
in
this
case?
Well
alice.
Is
the
system
context
right,
so
what
is
happening
in
wonderland?
Well,
wonderland
is
going
through
and
loading
all
of
the
let's
see
so
so
wonderland's
just
gonna
be
an
alias
for
system
context,
so
we
can
say
from
wonderland
and
poor
dallas.
So
so
in
this
case
it
would
be
for
thought
in
alice
right.
A
So
then
you
know
we
already
have
code
that
handles
transparently
the
run
you
when
you're
in
a
nested
async
io
it
we
we've
got
all
the
code
for
that
right
now.
I
think
I
think
there
is
a
feature
branch
somewhere
which
attempts
to.
A
Within
method,
so
this
is
for
this
is
this:
is
this
is
just
I
mean?
Well,
you
can
see
it
so
so
there's
some
bugs
basically,
and
so
we
are
for
some
reason.
I
don't
know
if
there's
some
bugs,
maybe
there's
not
even
some
bugs,
I'm
not
sure.
What's
going
on
here.
Suffice
it
to
say:
if
we
don't
do
this,
the
the
kernels
blow
up
when
we
run
them
in
testbook.
For
some
reason
I
think,
or
maybe
it's
within
the
actual
notebook.
I
think
no,
it's
within
the
textbook
yeah.
A
So
basically
we
we
check
once
if,
when
some
versions,
some
versions
of
ipython,
why
are
we
talking
about
this?
Okay?
The
point
is,
we
can
run
async
code
with
a
for
loop
as
if
it's
not
a
facing
code,
so
not
a
big
deal,
we'll
just
stop
talking
about
that.
Okay,
so
and
then
you'd
have
you
know
also
from
wonderland.async
import
alice,
which
would
allow
you
to
do
your
async
for
thought.
Analysis
right,
okay,
so.
A
I,
like
that
yeah
I
like
that.
That's
nice
right,
so
there
we
got
a
class.
So
this
looks
a
little
more.
This
looks
a
little.
This
is
looks,
looks
this
looks
a
little
more
reasonable
here,
so
basically
async
with
alice
as
alice
a
thinkforce.
A
Yeah,
so
perhaps
we
should
support
the
following
right,
so
perhaps
we
support
alice
system
context.
A
Okay,
so,
and
what
happened
here
so
so
we
are
playing,
remember
we're
trying
to
figure
out
what
is
the
most
ergonomic
api
right.
What
is
the
most
natural
feeling,
what
is
the
most
natural
mode
of
communication
with
alice
right
and
to
that
effect,
we're?
You
know
experimenting
with
this
with
this.
A
Okay,
so
basically
dot
dots
is
the
default,
which
means
the
call
will
do
the
default.
But
if
we
wanted
to
be
explicit
right
because
we're
in
this
block
from
334
through
337,
playing
with
the
explicit
api
so
and
we'll
just
put
this
after
right.
So
then
now
334
through
336,
is
playing
with
the
explicit
api
337
experiments
with
the
fact
that
the
thoughts
is
going
to
be
aliased
as
the
default
and
then
3
39
and
340
async,
with
alice's
ellis
and
async.
For
our
thought
and
alice.
A
We
play
with
a
you
know,
even
more
abstract
api,
where
we're
doing
a
single
context.
Entry
and
therefore
we
have
a
context
on
alice
and
on
342
and
343
we're
playing
with
a
non-async
version
of
an
iterator
where,
on
the
initial
iteration,
we
will
start
alice's
background
thread
right
and
basically
just
go
immediately
into
the
first
iteration
of
the
loop
that
we
might
see
after
337
or
after
336
right
the
body
of
of
what
would
be
the
loop
for
336.
A
A
So
so,
when
we
kick
this
thing
off,
when
we
kick
this
thing
off.
A
We
can
do
if,
if
the
default,
if
the
deep,
if
the
default
takes
no
inputs,
we
can
iterate
as
we
please,
with
342.
A
Okay.
Fourth
audit
analysis.
Fourth
thought
in
alice
for
thought
analysis
for
thought
in
alice,
poor
thought
in
alice.
So
how
could
we
make
it
so
that
we
can
interact
with
one
instance
of
alice
within
that
for
loop?
Or
maybe
we
don't
want
to
interact
with
one
instance
of
alice
with
the
not
for
loop?
Maybe
if
we
call
that
for
loop,
we're
expecting
that
we're
interacting
with
the
global
instance
valus
a
lot
of
people
like
globals.
A
A
A
A
I
think
we
can
do
this,
so
if
we
directly
import
alice
lower
case
from
wonderland,
we
can
we
can
just
instantiate,
we
can
do
what
we're
doing
on
345
within
the
body
of
the
loop
or
effectively.
You
know
whatever.
Basically,
when
we
do
the
first
iteration
we'll
start
here
and
we
will
create
the
new
instance
effectively.
A
A
A
Okay,
wait.
I
swear,
I
swear,
it's
gonna
be
easy.
What
are
we
gonna?
Do?
Oh
yeah?
We
don't
need
to
do
this
because
we
can
say:
okay,
so
def
alice
right,
so
we'll
basically
dynamically
populate
this
and
we'll
say
so.
This
will
be
like
you
know,
coming
from
this
sctx.deployment
python,
we'll
have
ctx
deployment
python.
A
A
A
A
A
A
Deployment
deployment
has
operations
for,
has
auto
start
inputs
or
not
non
auto
start
operations.