►
From YouTube: SES Meeting: Isolated Realms Presentation
Description
Leo Balter presents a coherent proposal for isolated realms.
A
All
right
welcome
to
the
meeting
leo
you're
up.
First,
oh.
B
Thanks
yeah,
I
prepared
some
slides
for
the
isolator
realms
they're,
just
pretty
rough
there's
still
a
draft,
but
I
just
want
to
like
start
capturing
slides
that
I
can
present
to
other
people
at
tc39
and
other
people
involved
like
including
tag
to
finish
up
the
tag
reveal
and
to
present
what
we
have
for
the
isolated
realms.
B
I've
been
noticing
like
as
we've
been
discussing
this
here
and
there.
I
am
like
very
comfortable
with
the
api,
but
people
are
still
expecting
to
see
something
different
like
people
are
not
really
capturing
all
the
changes.
So
I'm
trying
to
get
the
slides
to
show
like
what
is
new.
C
B
Yes,
yes,
and
at
the
same
time
I
tried
to
bring
this
presentation
just
to
discuss
the
next
steps
to
the
api.
I
still
didn't
have
time
to
finish
approach
with
polyfill,
because
it's
it's
also
like
really
hard,
and
there
is
so
many
people
just
bringing
so
many
questions
about
the
the
api.
I
need
to
find
a
way
to
quick,
tell
them
like
about
the
new
changes
like
to
explore
this
new.
This
new
approach-
I
am
people-
are
bringing
me
like
so
many
questions
here
and
there.
B
So
I
need
leo.
D
Are
you
sharing
your
screen,
not
yet
okay,
anything
yeah
mark.
We
need
to
work
on
that
one
just
a
matter
of
time.
B
D
B
Can
you
see
the
screen
where
it
actually
shows
a
slide?
Yes,
okay,
so
this
is
just
a
small
presentation
feel
free
to
interrupt
me
at
any
time.
I'm
just
gonna
try
to
show
like
what
is
new
with
this
api
and
are
some
discussions
we
already
have
open.
I
just
try
to
bring
the
outstanding
discussion
for
now.
B
This
is
a
current
proposed
interface
for
the
realms,
so
you
have
a
simple
constructor
with
the
import
binding
to
that
you
provide
a
specifier
string
and
you
actually
get
a
binding
name,
and
it
can
only
it
returns,
a
promise
that
is
always
resolved
to
a
primitive
or
callable
object,
and
also
evaluate
that
is
equivalent
to
an
evo,
but
also
can
only
evaluate
to
primitive
or
callable.
D
Go
back,
go
back
one
slide,
so
a
couple
of
notes
about
this
one.
So
I
I
use
evaluating
instead
of
eval,
because
trying
to
at
least.
D
Distantiate
ourselves
from
evolve
the
two
two
things
that
are
different:
the
first
one
is
that
if
you
pass
an
object
as
the
first
argument
right
now,
the
spec
that
we
finished
last
week
will
throw
an
error.
Obviously
that's
too
restrictive,
so
we'll
have
to
work
on
that
one.
But
the
problem
with
eval
remember
mark
is
that
if
you
pass
an
object,
it
returns
the
object
back.
C
Yeah
mike
samuel
had
this
proposal
for
fixing
that
so
that
he
could
do
this.
His
whole
typed
approval
thing
for
rebound,
but
I
don't
know
what
this
native
that
is.
D
Yeah
I
mean
either
so
for
now,
just
saying
evolution
is
not
equivalent
to
evolve,
doesn't
do
the
same.
It
returns,
it
only
accepts
certain
return
value
and
it
only
accepts
in
a
string
as
a
thing
that
you
pass
into
it.
We
could
go
ahead
and
do
the
to
a
string
on
the
first
argument
and
to
differentiate
even
more
for
an
evolve.
So
this
that's
kind
of
a
little.
D
B
D
Okay,
and
by
the
way
mark,
we
have
this
spec.
The
specs,
I
think,
is
very,
very
complete
at
this
point.
We
want
review
from
you
and
everyone
else
daniel
as
well,
where
we
are
with
that.
B
Yeah
just
for
clarity,
the
specs
like
for
me
trying
to
write
a
polyfill
without
a
spec
is
really
hard,
because
my
brain
still
like
on
all
the
test,
262
things
if
I
actually
have
a
spec
and
what
I'm
trying
here
is
just
like
to
finish,
propose
this
pack.
B
B
So
having
the
spec
helps
me
a
lot
moving
everything
ahead
with
a
polyfill
that
is
actually
solid,
consistent
with
what
we
can
have,
and
I
can
even
tell
like
all
the
things
are
different-
that
we
would
only
have
in
a
native
api,
okay,
so
moving
forward
yeah.
So
the
the
main
thing
that
is
actually
new
from
these
isolated
realms
is
that
we
don't
have
any
cross
ram
object,
transfer
the
new
ram
api
is
just
it
enables
communication,
but
it
transfer
anything
that
is
known.
B
B
It
fix
it
still
fix
things
such
as
identity,
discontinuity,
and
that
I
even
helps,
in
my
opinion,
that
it
even
helps
on
like
not
not
providing
fingerprints
across
realms.
B
D
Well,
I
think
those
two
reasons
are
not
the
main
objective
of
the
wrapping
of
collar
balls.
I'll,
say.
The
reason
why
we're
doing
the
auto
wrapping
of
callable
is
is
a
is
a
ergonomics
and
convenience
basically
for
for
someone
to
be
able
to
write
a
program
that
can
communicate
back
and
forth
between
the
two
realms
and
fingerprinting
or
or
what
was
the
other
one
that
you
mentioned
the
the
first
one
and
that's.
D
And
it's
not
about
identity,
so
I
I
think
I
think
identity
qualified
as
one
of
the
reasons
for
it
is
just
ergonomics.
This
is
convenience
and
ergonomics.
B
Okay,
yeah,
it's
also
ergonomic.
Yes,
I
think
like
this
api,
if
I
have
to
provide
a
pin,
I
think
this
api
is
even
more
economic.
In
terms
of
like
I
like
the
way
we,
we
actually
said
things
here
and
there
across
realms,
so
yeah,
that's
what
I
said
about
like
functions
are
not
directly
transferred
we're
just
we
just
connect
them
within
the
realms
when
what
so?
What
happens
here?
B
If
when
we
want
to
send
a
callable
object
and
I'm
going
to
talk
about
color
object
further
in
this
is
on
the
slides
and
we
just
create
a
new
wrap
function
in
the
receiving
realm.
So
I
have
some
examples
here.
Just
try
to
short
this
example
and
try
to
highlight
the
part.
So
here
I
have
this
wrapped
wrapped.
It's
just
a
wrapped
function
that
is
connected
to
the
return
of
the
other
realm.
B
So
wrapped
is
connected
to
this
error
function
and
error
function
when
called
receives
the
argument,
the
parameter
x
and
set
sex
to
a
global
base,
and
this
code
is
running
in
the
inside
of
the
new
constructed
realm
and
it
returns.
Okay,
the
string
okay.
So
here
I'm
calling
wrapped
and
I'm
capturing
the
return
from
from
wrapped
there
in
in
my
realm
and
then
when
I
checked
the
global
realm,
has
a
global
base
received
with
the
value
that
I
set
from
right
can.
D
B
B
So
the
the
first
first
line,
I'm
constructing
around
second
line,
I'm
actually
getting
a
wrapped
function
for
using
realm
evaluate
and
the
third
line,
I'm
actually
getting
a
wrapped
function
from
code
that
I
inject
using
import
binding
for
the
examples
I'm
using
evaluate
to
better
illustrate
what
what's
the
code
underneath
and.
D
Maybe
maybe
maybe
removing
this
one
because
yeah,
I
think
if
at
some
point
before
you,
you
mentioned
that
you
you
have
two
ways
of
evaluate
code,
one
is
evaluated
and
the
other
one
is
import
binding
and
what
that
does
then
you
don't
have
you
don't
need
this
one
necessarily
yeah.
B
B
When
I
actually
had
my
last
example,
I
was
just
wrapping
a
function
I
received
from
rom
evaluate,
but
I
can
also
like
send
a
functions
here
and
there
now
I'm
using
the
example
using
the
import
binding.
B
A
What's
that
sorry,
I
was
just
like:
are
you
serious.
B
B
B
So
here
is
just
a
connection.
Do
something
is
a
wrapped
function
connected
to
run
and
when
I
call
the
function,
I
also
like
kev
send
another
function
that
is
wrapped
within
the
constructor
row
that
I
try
to
represent
and
illustrate
this
example
here
saying
like
when
I
call
do
something
I
actually
call
called
run
with
a
wrapper
for
for
this
callback
function
like
we
don't
have
a
name
for
it.
We
just
have
like
the
idea
that
the
error
function
is
wrapped
inside
the
realm.
B
Oh,
yes,
I
have
a
weight
miss
in
there
thanks
for
I.
I
basically
just
did
these
slides
yes,
and
thanks
for
capturing
that
part,
import
biting
is
a
returns,
a
promise
that
actually
resolves
the
names
async
so
by
callable
objects
that
I
now
that
I
mentioned
called
objects.
So
often
here,
it's
anything
with
a
call
internal.
B
It's
not
limited
to
ordinary
function.
That
means
we
can
transfer
function.
Our
functions
bound
functions
and
we
can
also
transfer
proxy
wrap
functions.
We
can
transfer
more
things,
we've
not
transferred.
We
can
connect
more
things
and
can
auto
wrap
more
things,
of
course,
but
one
of
the
goal
like
when
we
call
callable
objects
is
that
we
mean
we
can
also
send
gullible,
proxies
proxies
that
have
a
function
as
a
target
and
question.
C
So
the
so
an
object,
especially
like
a
a
a
proxy
objects,
have
a
lot
of
stuff
to
them.
In
addition
to
their
call
behavior,
I
take
it
that
the
rapper
is
only
trying
to
mirror
the
call
behavior
and
not
any
of
the
other
aspects
right
in
particular,
not
the
construct
behavior.
Is
that
correct.
D
Right
right
and
then
the
spec
right
now
when
we
found
a-
and
this
is
a
another
open
question-
the
the
way
I
wrote
the
spec
is
that
we
detect-
that
is
a
callable.
D
We
don't
at
the
time
of
wrapping
or
creating
the
wrapper.
We
do
not
care
about
the
construct
behavior,
we
only
care
about
the
construct
behavior.
Let
me
see
if
I
remember.
D
I
believe
at
the
time
of
wrapping,
I
don't
care
about.
I
only
check
if
it
is
a
callable
and
there
you
can
show
the
the
spec
quickly
and
then,
when
the
time
comes
to
do
the
invocation,
I
believe
I
believe,
on
allowing
the
construct
behavior
to
happen,
but
with
the
restrictions
of
the
wrapping
mechanism,
which
makes
the
the
construction
path
a
lot
more
useless.
D
Let
me
see
there,
so
this
is
for
the
no
actually
you
scratch
that
we
only
have
the
call
we
gave
you
you're
right.
If
you
try
to
do
new,
we
do
not
have
that
the
construct
behavior,
you
don't
have
construct
yeah.
It
just
just
throws
an
error.
D
C
C
E
B
Right,
good
there's
just
one
thing
that
I
want
to
discuss
with
curry
further.
Also
like
one
question
for
later:
I'm
not
sure
if
we
say
anything,
but
we
should
probably
specify
the
wrap
function.
Exotic
object
should
have
function,
dot
prototype
as
their
pro
as
their
internal
prototype,
but
that's
for.
A
D
D
The
spec,
by
the
way
we
don't
have
that
kind
of
thing
in
the
spec.
So
I'm
improvising
a
little
bit
like
I'm
setting
the
prototype
to
function
prototype
from
color
realm.
You
don't
have
the
front
anymore
and
they
respect
today.
So
yeah.
E
D
Saying
like
doing
that,
color
rom
dot
percent
function,
prototype
percent.
D
That's
probably
true,
but
no
about
four
two
doesn't
have
two
realms:
it
only
does
they
bigger
than
small
land
kind
of
thing
for
special
slots,
sl
that
have
dynamic
names.
A
Yeah
one
other
thing
to
note:
we
probably
should
never
allow
construct
to
be
wrapped.
I
think
if
you
try
to
extend
a
class
which
has
the
extends
clause
hierarchy
point
to
one
of
these
rap
things,
things
would
get
bizarre,
especially
with
new.target.
I
don't
know
how
you
would
be
crossing
realms
for
that.
C
Yeah,
that's
a
great
example.
Membranes
handle
new
target
correctly.
Anything
shorter
membranes,
neutral
target
would
be
a
mess.
B
B
There
is
no
way
to
actually
try
to
construct
anything
using
this
wrapped
function
that
would
actually
defer
to
to
the
other.
D
D
E
D
B
C
B
D
B
And
also,
in
any
case,
I
have,
I
have
an
example
of
that
in
the
slides,
but
even
if
you
call,
if
you
try
to
it,
tries
to
return
any
sort
of
object,
it
will
fail
anyway,
I'm
going
to
be
talking
about
errors,
really
quick,
so
yeah
here
is
an
example
of
just
of
me
just
getting
a
transfer
in
a
proxy
to
the
other
realm,
not
transferring.
B
B
This
is
an
exercise
that
I
need
to
do
for
homework.
Okay,
so
this
is
in
this
example.
Here
I'm
just
connecting
this
callable
proxy
with
the
other
realm.
B
B
B
Also
with
the
more
examples
of
known
callable
objects,
an
attempt
to
transfer
no
callable
object
values
would
throw
a
type
error.
That's
what
happens
initially
and
I
here
I
have
some
examples
trying
to
show
like
where
this
error
happens,
because
there
is
a
question
like
if
the
error
will
happen
in
the
realm
or
in
the
in
the
incubator
realm
or
in
the
constructor
realm.
B
So
here
when
I
try
to
evaluate
and
evaluate
actually
resolves
devaluation
into
an
object,
I
get
an
that.
Realm.Evaluate
could
throw
a
typo
in
my
incubator,
around
yeah.
B
And
for
for
these
following
example,
oops
wrap
functions
also
cannot
receive
non-callable
objects,
so
I
still
have
to
do
something
function
here
and
here.
In
this
example,
I
even
extended
to
say
to
show
like
evaluate
is
not
even
so
it
when
I
have
the
realm
evaluate,
do
something
is
connected
to
an
error
function
that
would
set
a
global
value.
The
global
date
is
not
called
so
when
I
try
to
call
do
something
trying
to
transfer
in
an
ordinary
object.
B
I
can
see
the
error
still
a
type
error
and
the
global
this.call
in
the
other
realm
is
still
not
called
like
it.
There
is
no
calling
there
is
no
evaluation.
If
I
don't
use
that
argument,
and
here
in
this
other
example,
I
have
an
error
happening
in
the
inner
round
in
the
constructor
realm
same
thing,.
B
B
Just
because,
in
this
case,
I
have
do
something
that
receives
an
argument:
callback
and
I'm
sending
a
narrow
function
that
I'm
calling
poison
because
poison
is
still
a
callable
object.
So
I
can
still
transfer
it
when
you
call
do
something.
But
when
I
try
to
call
this
callback
inside
the
realm,
it
tries
to
return
a
an
ordinary
object
again
and
it
would
throw
from
inside
and
there
in
capturing
this
error.
D
B
I
I
have
the
examples
for
that
just
hold
on
please.
Yes,
the
idea
is
I'm
trying
to
progressively
show
the
examples,
instead
of
just
trying
to
throw
them
out
to
everyone.
It's
too
much
information,
so
here
I'm
not
using
the
poison,
but
actually
using
an
error.
That
is
probably.
B
Okay,
here
I'm
using
a
next
sample
that
I'm
actually
trying
to
transfer
array
array
is
an
actual
function.
It
does
have
the
call
ability,
but
it
just
returns
a
new
object
when
you
call
array
so
yeah.
So
if
I
try
to
call
do
something
array,
it
too
can
transfer
a
connect
array.
You
so
so-called
back
is
a
wrapped
function
connected
to
array
from
my
incubator
realm.
But
if
I
try
to
call
callback,
it
will
draw
a
type
error.
B
I
have
all
of
my
examples
just
using
this
error,
I'm
trying
to
fix
all
of
them.
D
Well,
if
you,
you
show
the
spec
quickly,
the
any
error
that
occurred
on
the
other
side,
whether
that's
because
they
are
the
incubator,
realm
is
calling
the
function
or
the
realm
is
calling
a
function.
D
That
was
wrapped
either
way,
and
this
is
also
a
interesting
conversation
to
have
as
a
step
number
eight
once
we
finish
to
call
the
the
when
the
the
the
function
that
is
being
wrapped,
finished
the
completion
we
received,
the
completion
record,
we
determined
that
the
only
thing
that
is
this
function,
this
function,
that
the
wrap
function
can
return,
is
a
normal
completion
and
if
it
is
not
a
normal
completion,
we
we,
we
created
a
new
type
error
for
the
color
realm.
D
Now
we
know
that
we
have
multiple
completion
types.
We
don't
not
only
have
the
normal
completion,
we
we
also
have
the
break
the
continue
and
and
the
the
obviously
the
error
itself,
the
abrupt,
the
throw
none
of
those
qualified
as
a
proper
result.
So
that's
why
we
only
focus
on
the
normal
one.
D
Now,
in
the
future,
we
decide
that
we're
going
to
also
do
something
about
maybe
promises.
We
could
we
could
revisit
this
and
open
the
door
for
promise
to
also
be
wrapped.
That
means
a
completion
record
for
other
things
like
a
break
or
continue,
and
so
on
might
work.
C
Can
a
function
ever
terminate
with
a
break
or
continue
completion?
I
don't
think
so.
E
Yeah,
I
think
the
only
things
that
could
reach
this
path
are
our
exceptions,
but
I
think
that
this,
this
idea
of
replacing
all
the
things
that
are
thrown
with
a
new
fresh
type
air
seems
very
sound
to
me
and,
like
a
membrane
system,
will
probably
not
reach
this
path,
we'll
probably
instead
catch
the
errors
beforehand
and
then
send
something
that
that
can
be.
You
know,
shared
to
the
other
side
or
transferred.
D
Right
to
me,
okay,
can
you
scroll
down
a
little
bit
more
leo?
I
think
I
put
also
a
node
somewhere,
I
don't
know
somewhere.
I
put
a
node
saying
that
the
this,
the
specification
of
thing
has
anything
about
the
stack
trays
and
so
on,
and
so
I
suspect
that
the
implementers
can
decide
what
kind
of
information
that
error
will
have.
D
E
It
might
be
the
truncated
information
if
we're
claiming
that
this
is
some
kind
of
boundary,
then
you
know
there's
already
a
place
where
the
web
platform
does
this.
When
you
have
a
a
cross-origin
script
tag
and
then
there's
an
error
from
that,
then
that
error
gets.
You
know
you
don't
get
to
see
what
happened
there
in
this
case
feels
really
similar.
So.
E
C
B
I
am
too
good
so
moving
on
so
here
I
have
the
a
near
the
abrupt
completion
from
the
evaluate,
and
what
I
want
to
highlight
here
is
just
like
the
realm
is
actually
throwing
a
normal
error,
and
but
we
always
capture
the
type
error,
probably
like
the
specs
that
we
just
showed
here
describe
these
better
for
this
group.
B
B
Okay,
one
of
the
things
that
is
actually
important.
When
we
talk
about
this
connected
functions,
they
are
not
transferred
it's
because
they
also
like
won't
carry
properties.
So
here
I
have
a
function.
Fn
and
I
try
to
add
properties
like
I
try
to
call
to
add
secrets
to
this
function
and
when
I
get
do
function,
of
course,
there's
something
it's
missing.
The
function
here
I
received
the
cb
here
is
a
the
wrapped
function
connected
to
fn,
but
cbs2
doesn't
have
any
secret.
It
still
doesn't
have
any
property
secret
secrets.
D
C
B
We're
doing
yet
examples
too
so
yeah.
This
is
the
general
overview.
Just
gonna
bring
some
outstanding
discussions.
A
Can
we
can
we
go
back
a
couple
slides,
please
I
spotted
something
here
that
might
be
interesting
with
regards
to
membranes.
It
could
be
that
the
maybe
this
isn't
relevant.
I
don't
know
yet.
A
I'm
thinking
about
the
case
of
static
properties
on
a
class
stack,
as
I
recall,
that'd,
be
sort
of
similar
to
what
you're
talking
about
here.
If
we
tried
to
pass
a
class
into
the
realm,
this
is
implying
that
the
classes,
static,
properties
and
methods
would
not
be
carried
along
with
it.
D
Yeah,
like
the
classes,
would
not
work
across
realm,
so
really
you're
just
getting
a
call
level.
You
try
to
do
to
call
it.
What
does
it
do
when
you,
when
you
get
a
class
today?
What
does
it
do
when
you
call
it?
It
throws
an
error,
because
you
have
to
knew
it
and
that's
what
you're
going
to
get
here.
D
C
C
C
C
C
Really
it's
really
crucial
to
just
get.
The
layering
of
this
thing
is
not
a
membrane.
This
thing
is
something
with
which
to
implement
the
membrane.
Membranes
are
going
to
do
the
identity
tracking.
This
one
should
not,
because
if
we
do
then
we'll
have
two
partially
redundant
interfering
identity,
tracking
mechanisms.
D
Yeah
one
one
thing
very
interesting
things:
observations
in
general
that
I
have
found
when
thinking
about
putting
a
membrane
on
top
of
these
or
even
a
more
simple
implementation,
not
necessarily
a
membrane
and
array
seems
to
be
a
crucial
aspect
of
javascript
program.
So
how
do
you
transfer
a
non-deterministic
list
of
things
to
the
other
side
seems
like
it's
very
hard
to
do
it,
but
it
turns
at
the
beginning.
I
was
saying
okay
well,
this
is
going
to
be
a
problem
like
in
the
case
of
a
class.
D
D
So
if
you
call
a
wrap
function-
and
you
pass
n
number
of
arguments,
then,
on
the
other
side,
you
can
just
in
the
rate
and
function
that
you
prefer
to
receive
those
arguments.
You're
just
receiving
an
array
of
them,
if
you
do
the
proper
declaration
for
that,
so
there
are
ways
in
which
which
will
be
able
to
transfer
a
large
quantity
of
data
between
those
functions
in
terms
of
providing
the
foundation
for
a
membrane
to
be
built
on
top
by
providing
that
those
shapes.
D
So
I
was,
I
was
experimenting
with
something
like
you
pass
a
number
and
kind
of
appear,
a
key
value
pair
by
using
the
arguments
for
that,
where
the
order
in
which
those
arguments
arrive
can
be
analyzed
on
the
other
side
and
re,
create
the
shape
of
the
class
or
recreate
the
shape
of
an
object
on
the
other
side.
D
B
B
Okay,
so
trying
to
move
forward.
There
is
another
outstanding
question
on
this,
which
is
actually
a
little
bit
more
cloudy
here
on
what
we
where
we
should
actually
go.
B
There
are
occasions
where
we
don't
need
to
import
any
name
most
of
these
for
user
code
injected
that
we
inject
into
a
round.
In
this
example,
here
I
have
a
test
framework
example
and
where
I
actually
load
my
test
framework.
D
Yeah,
I
think,
yeah
I
think
we
will
have
to
have
a
regular
import
by
then
that
has
a
problem.
Oh
yeah.
I
have.
B
I
I
stress
out
these
options
here.
D
D
B
D
Are
you?
Oh
I
I
don't
remember
what
I
did
on
the
spec
for
that?
That's
the
part
that
is
very
flacky,
because
it's
a
host
describing
the
host
behavior
will
have
an
eu
test
framework
does
not
have
a
run
export
today.
I
think
that
it
throws
an
error
it
it
it
resolves
to
it.
It
actually
throws
them
on
the
promise
yeah.
B
Yeah,
so
there
is
actually
one
thing
with
the
status
quo
here
as
well.
I
probably
need
to
write
this
down,
but
like
this,
article
quote
for
now
is
like
the
binding
name
is
always
required,
but
we,
but
even
if
the
name
is
always
required,
you
can
still
write
another
module
code.
That
does
these
things
like
that,
those
loads,
the
test
framework
and
the
other
file.
You
don't
need
to
load
them
directly
into
your
incubator
realm,
so
you
just
you,
can
just
create
a
layer
on
top.
D
B
A
D
C
D
Yeah,
it
must
be
you
little,
the
maybe
drop
the
bpm
or
something,
but
the
we
talk
about
creating
a
exotic
name,
space
object
that
that
that
might
be
an
antenatal
solution.
We
talk
about
it,
danielle
myself
on
leo,
I
think,
rather
than
importing
one
binding,
we
import
the
the
entire
thing,
but
what
we
get
back
is
a
exotic
another
exotic
name:
space
object
that
wraps
the
entire
name
space
out
to
you,
which
is
also
an
exotic
copy
anyways.
D
And
then,
if
you
try
to
access
one
of
the
bindings
at
any
given
time
and
the
binding
is
not
a
primitive
or
callable,
it
throws
an
error.
That's
another
alternative,
so
we
eliminate
these.
We
are
api,
I'm
I'm
fine
with
that
one
too,
but
I
think
daniel
has
some
objections
about
that.
One
sorry,
it
doesn't
work,
doesn't
make
reactions.
D
B
All
right,
I'm
sorry
if
I
talked
on
top
of
anyone,
because
my
audi
was
cutting
off
and
I
couldn't
hear
anyone
else,
it
should
be
solved
now,
yeah,
so
the
alternatives
to
that
we
can
explore
to
import
to
for
this
import
fighting.
This
is
my
least
favorite
one.
The
alternative
one
is
actually
having
import,
binding
and
realm.import.
B
B
So
when
I
have
the
example
here
I
have
the
dot
I
change.
I
replace
report
binding
with
a
round
prototype
import
with
the
specifier
in
an
options
back,
and
I
say
the
binding
that
I
want
these
actually
matches
my
this
actually
matches
the
import,
the
sessions,
the
options
back
in
the
reporter
sessions,
where
you
have
a
cert
type
inside
this
object,
we
use
for
options.
D
B
D
Yeah,
which
would
kind
of
mess
my
head,
because
people
already
has
a
predisposition
for
import,
what
what
it
returns.
Yes
and
and
that's
why
I
was
proposing
the
wrapping
of
the
name
space
object,
which
doesn't
seem
like
a
weird
to
too
weird,
and
then
it's
very
easy
to
teach
people
like
you're
importing
that
one's.
B
Talk
about
it
before
I
go
to
the
next
slide.
I
also
like
start
of
school
is
also
like
an
option
too.
I'm
just
providing
alternatives
to
the
current
status
quo.
Startup
score
is
good.
It's
good
too.
I'm
just
bringing
this
to
the
discussion
to
make
sure
we
explore
these
parts,
so
alternative
three
is
actually
having
a
module
named
base
resolver.
B
This
is
also
inspired
another
suggestion
from
matthew
huffman.
There
is
a
threat
discussion
going
on
about
this,
and
this
is
a
little
bit
weird
and
it
seems
like
a
little
bit
overkill
and
I'm
not
sure
if
I'm
touching
the
responsibility
of
a
membrane.
B
So
what
I
have
here
is
a
round
module
resolver,
I'm
calling
giving
this
name
in
lack
of
like
a
better
name
in
this
shortness
of
time.
So
when
I
import
the
round,
I
like
I
just
run
one
import
and
I
have
a
special
object
that
does
have
a
get
function.
Does.
D
B
Have
anything
else
just
to
get?
I
I
thought
about
like
using
a
map,
but
I
don't
see
any
usefulness
or
anything
from
anything
else.
A
map
can
provide
to
me,
but
like
there
is,
there
is
nothing
I
can
actually
use
from
maps
that
I
like,
or
that
I
want
from
this.
I
just
want
to
get
to
get
the
binding
value,
because
what
we're
getting
here
is
just
a
binding
value
and
the.
C
E
A
That
and
if
the
module
is
a
then
a
ball
module,
you
have
problems,
because
that
would
return
a
promise
and
you
would
never
be
able
to
actually
import
those
modules.
A
You
have
an
enable
module,
a
module
that
exports
a
den
function,
it
would
end
up
being
chained
in
the
promise
and
the
then
function
will
automatically
be
called,
which
returns
a
promise
which
would
break
the
throw
it
will
throw.
In
that
case,.
D
E
A
E
A
A
Nothing
on
the
relevant,
pointing
it's
the
regular
promise
resolution,
because
the
realm
import
returns
a
promise
and
when
you
do
promise
resolution
with
an
object
that
has
a
then
function
that
then
function
is
automatically
called
by
the
promis
resolution
mechanism.
B
I
think
we
need
to
defer
some
discussion
on
what
is
actually
the
resolution
like
if
test
framework
is
a
has
a
venable
name
space.
We
should
probably
discuss
further,
but
not
here
what
is
round
module
like
a
resolution
of
the
then
mobile
namespace
or
just
the
namespace
that
has
then
function.
C
Speaking
for
a
bunch
of
us,
we
have
an
eleven
o'clock
meeting
yeah.
B
And
that's
that
is
just
it
and
the
other
last
part
is
just
a
bike
shed
here.
I
have
an
example
of
all
the
alternatives,
the
other
the
last
one
was
just
a
bike
sharing
with.
If
we
stick
with
import
binding,
we
should
probably
discuss
in
actually
getting
renaming
it
to
import
value.
It's
because.
D
It's
not
a
dynamic
binding.
My
feedback
in
general
feedback
is
that
examples
are
great,
but
we
need
to
do
better
at
the
beginning
of
it
explaining
what
this
is,
because
this
group
has
already
a
lot
of
knowledge
about
what
this
is
and
the
direction
we're
going,
but
the
bigger
group
will
have
will
be
lost
in
the
examples,
without
understanding
what
we're
trying
to
do
in
terms
of
the
separation
of
the
realm
like
so
the
iso
later
on,
you
have
to
provide
a
lot
more
context
before
we
get
into
the
examples.
A
B
Yeah,
I
I
I
needed
to
present
this
to
make
sure
like
what
I
need
to
add
next,
I
my
goal
is
actually
to
improve
this
for
the
next
tc
39
meetings
and
tag
and
present
to
everyone,
but
like
it's
easy,
it's
good
to
capture
outstanding
questions
from
this
meeting.
A
It's
wonderful
to
see
progress
made
in
a
direction,
that'll
be
amenable
to
the
browser
vendors.
Thanks
for
the
presentation.
Thank
you.
Given
that
we're
out
of
time,
I'm
going
to
stop
the
recording
thanks
again.