►
From YouTube: SES Meeting: Records, Tuples, and Cross-Agent Realms
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
I
I
I
I
I
was
very
favorably
inclined
towards
the
records
and
people's
proposals
simply
because
it
gave
us
a
way.
It
gave
us
one
more
place
where
we
wouldn't
have
to
use
harden,
and
in
particular
it
gave
us
a
way
to
express.
B
Recordings
on,
let
me
sort
of
recap,
to
give
a
little
bit
of
context
I'll
try
to
do
it
quickly,
so
we've
got
several
agenda
topics
today.
B
The
particular
thing
that
I
got
started
with
is
the
question:
are
records
and
tuples
permanently
deadlocked
on
minus
zero,
because,
as
far
as
I
can
tell,
the
answer
is
yes,
the
problem
is
that
the
only
sensible
semantics
for
after
much
debate,
I
became
convinced
the
only
sensible
semantics
for
a
singleton
tuple
of
zero
triple
equal
singleton
tuple
of
minus
zero
is
yes,
they're
triple
equal
because
triple
equals
should
be
recursively
triple
equal
and
otherwise
using
an
array
is
to
be
using
a
tuple
to
represent.
B
Let's
say
a
singleton
vector
is
inconsistent
with
with
arithmetic
on
scalars,
if
you're,
just
trying
to
think
of
these
arithmetically.
At
the
same
time,
the
way
to
achieve
that
by
coercion.
One
entry,
where,
where
a
tuple
of
minus
zero
trying
to
formulate
a
tuple
of
minus
zero,
becomes
a
tuple
of
zero
making
that
happen
on
entry.
B
It
conflicts
with
the
storage
and
retrieval
semantics
of
-0
in
normal
arrays,
which
doesn't
do
any
coercion,
and
it's
just
surprising
from
a
perspective
of
values
as
computationally
observable
entities.
So
I
think
that
there
is
a
sensible
semantics
here.
B
I
think
there's
exactly
one
sensible
semantics
and
the
implementers
have
vetoed
their
ability
to
implement
that
one
or
their
willingness
to
implement
that
one
because
of
the
difficulty
of
the
the
kind
of
memoization
for
doing
a
quick
comparison
of
of
these
things,
you'd
have
to
memoize
equivalence
classes
rather
than
memoize
only
one,
and
without
the
implementers
being
willing
to
do
that
one.
I
don't
think
that
there's
any
other
semantics.
That
is
that
it.
That
is,
I
think
there
is
no
semantics.
B
A
Do
the
two
different
hardware
are
the
two
different
hardened
arrays
triple
equals,
or
no
not?
Definitely
not,
then,
the
the
defining
difference.
B
Is
that
right.
A
So
this
feels
like
this
is
very
frustrating,
because
this
feels
like
both
yes,
I
can
see
that
this
is
a
real
problem
that
is
thorny
to
resolve
and
at
the
same
time,
this
feels
like
a
really
stupid
problem
to
get
stuck
on.
B
B
Yeah,
but,
but
keep
in
mind
that
our
intuitions
about
scale,
things
that
are
minor
discrepancies
can
often
stop
the
world.
I
mean.
A
B
A
A
That's
an
excellent
that's
an
excellent
analogy.
B
So
I'll,
so
let
me
let
me
talk
about
the
what
I
think
remains
attractive
and
in
fact,
in
a
world
without
records
and
tuples
becomes
that
much
more
attractive.
Is.
B
As
long
as
you
know
that
they're
deeply
only
data,
then
you
can
pass
them
between
threads
between
agents,
sharing
an
address
space
by
just
passing
a
pointer
without
without
any
copy
overhead.
That's
under
the
assumption
that
you're
wanting
running
one
garbage
collector
over
the
whole
thing,
so
they
can
share
heap
representation.
B
But
what
peter
peter
hoddy
and
patrick's
okay
of
pointed
out
is
that
in
their
world,
where
there's
only
one
realm
and
all
the
primordials
are
frozen.
You
know
they're
cess
world
and
all
the
primordials
are
frozen.
They
can
take
deeply
frozen
immutable
object,
structures
and
directly
pass
them
between
agents,
because
they're
completely
thread
safe.
If
they're,
deep
and
and
the
thing,
that's
the
that
that
you
know
I
kind
of
understood
at
the
time,
but
it
only
struck
me
yesterday
in
correspondence
with
peter.
B
Is
that
the
fact
that
both
both
agents-
you
know
all
the
agents
that
are
communicating
this
way
share
a
single
set
of
frozen
primordials
with
a
single
set
of
object?
Identities
means
that
you
have
a
cross
agent
realm
and
it
works
all
of
the
objects
that
contain
any
mutable
state.
Reachable
anywhere
within
them
are
completely
disjoint
object,
graphs
between
the
agents,
but
anything
that
is
purely
transitively
immutable.
That
has
no
mute.
B
That
has
no
mutability
reachable
anywhere
in
in
that
subgraph
are
completely
shareable
between
the
agents,
because
the
two
agents
are
really
in
one
realm,
because
all
their
primordials
only
have
a
single
identity.
You
don't
have
to
translate
identities
when
you
trans,
when
you
move
these
objects
between
the
agents.
So
that's
just
kind
of
mind-blowing.
B
And
the
other,
you
know
preference
the
modelable
express
that
I've
come
to
be
in
agreement
with,
especially
with
this
perspective
of.
B
B
Invest
in
supporting
better
the
immutability
of
the
objects
we've
got,
and
I
I
can
I
can
I
can
feel
I
can
already
genuinely
argue
and
genuinely
feel
both
sides
of
that
argument,
but
I
do
think
that
records
and
tuples
are
deadlocked
on
minus
zero.
So
I'm
now
much
more
inclined
towards
peter's
side
of
that
argument,
and
and
and
and
in
any
case
the
cess
group
has
been
needing
to
see
more
investment
happen
in
immutability
for
object,
graphs
anyway,
such
as
with
hardware
and
with
purify
and
with
lockdown,
etc.
A
So
the
as
I
was
starting
to
say
when
we
we
kind
of
took
a
detour
to
deal
with
getting
recording
going
on.
All
of
that.
One
of
the
great
one
of
the
useful
virtues
to
me
of
the
records
and
google's
proposal
is
that
it
gives
a
way
it
gives
a
programmer
a
convenient
affordance
for
expressing
a
complicated
immutable
structure
as
a
literal,
as
you
know,
first
class
literal,
rather
than
having
to
create
a
mutable
thing
and
then
later
transmogrify
it
into
an
immutable
thing.
A
B
But
from
the
point
of
view
of
programmer
readability,
I
mean,
as
we
as
we
now
have
tremendous
amount
of
experience.
Programming
in
sets
is
that
harden
and
then
within
the
hardened
parentheses,
just
writing
out
a
big
nested.
You
know
object
or
literal
array
literal
function,
literal
as
we
do
where
all
of
the
stuff
there
is
just
appearing
literally
harden
of
that
does
produce
well
ignoring
the
functions
for
a
moment.
Pardon
of
that
does
produce
something
immutable
with
functions.
B
A
Yes,
my
my
issues
harden
is
just
I
detest
it
from
a
notational
point
of
view.
I
hate
I
would
I
would
much
I
would
like
to
be
sort
of
just
reflexively
anytime,
I'm
creating
something
is
going
to
be
immutable.
A
Have
it
be
immutable
but
having
hardened
sprinkled
all
throughout
my
code
is
just
horrible
and
it
would
be
great
if
there
were
a
lighter
weight
way
to
express
that
which
the
records
and
tuples
proposal
gives
us
and
there's
a
separate
question
of
of
you
know
how
efficient
is
it
and
how
fast
is
it
all
of
that?
But
I
I'm
I'm,
I'm
counting
on
implementation
magic
to
deal
with
that.
Ultimately,.
B
I
think
that
that
the
kind
of
static
analysis
that
we
do
in
our
head,
when
we
see
a
hardened
around
a
bunch
of
literal,
just
expressed
literally
in
line,
we
know
that
it's
transitive
across
at
least,
what's
being
literally
expressed.
I
think
that
engines
could
do
a
lot
of
that
static
analysis
safely.
Once
hardened
is
recognized
by
the
clef
there
has
there
have
been
proposals
actually
much
older
than
records
and
tuples.
B
I
think,
starting
with
brandon
to
say,
let's
just
introduce
a
more
declarative
syntax
for
for
for
expressing
literal
structure,
that
is,
that
is
born
frozen
for
expressing
frozen
literals
directly.
Yes,.
A
B
Yeah
I
mean
the
so
the
the
thing
one
can
contemplate
is-
and
I
think
this
goes
back
to
sort
of
the
history
of
the
notation
is
that
whatever
notation
was
proposed
for
records
and
tuples.
If
records
and
tuples
are
deadlocked,
just
have
that
notation
be
a
way
to
write
frozen
objects.
A
Right
and
what
we,
what
we
lose
with,
that
is
the
ability
to
compare
that
compare
two
structures
with
triple
equals,
which
is
the
thing
they're
stuck
on
and
since
we
don't
have
that
now
it's
it's
it's
an
improvement
from
a
notational
perspective.
It
doesn't
deal
with
this
other
inconvenience,
but
we
already
had
to
deal
with
that
other
inconvenience.
So
it
is
a
strict
improvement.
B
Yeah
and-
and
you
know
what
that
means-
is
that
that
that,
when
you
do
want
to
do
a
structural
comparison
rather
than
an
identity,
comparison
of
these
kinds
of
structures,
you
need
to,
you
know,
introduce
a
new
library
comparison
thing
like
we
have
categoric,
with
our
same
structure
thing
because
of
the
blocks,
these
markers,
and
that
requires
a
you
know,
sort
of
another.
B
A
semantic
stance,
above
just
what
javascript
gives
us
about
at
what
point
you
know:
what
are
you
taking
as
an
indicator
of
what
substructure
should
be
recursively
compared
structurally
versus
which
substructure
are
actually
objects
that
should
still
be
that
should
be
interpreted
as
objects
with
identity
and
compared
by
identity,
and
we
have
that
algorithm
with
pass
by
copy
objects
versus
presences,
and
I
think
that's
the
right
thing
for
doing
distributed,
object,
programming
and
distributed
object.
Programming
is
really
sort
of
the
right
starting
point
for
thinking
about
multi-agent
programming
anyway.
B
A
Right
I
mean,
I
think,
that
if
I
understood
your
comment
about
the
thing
you
you
grok
from
peter,
it's
that
essentially
the.
A
The
sort
of
the
moral
equivalent
of
well
it's
all
in
rom,
so
it's
never
going
to
change
is
is
is
that
in
fact,
you
can
do
pointer
comparison,
because
that's
just
how
it.
A
B
A
B
C
C
So
because,
because
symbols
carry
identity
with
them
in
normalization
of
a
structure
that
is
record
and
tuple
compatible
becomes
possible
and
then
another
one
of
the
big
benefits
is
being
able
to
use
them
as
lookup
keys,
where
the
symbol
just
is
effectively
a
proxy
in
your
polyfill
of
the
hopeful
future
record
and
tuples
in
the
language.
B
Okay,
but
the
since
it's
an
equivalence
class,
it's
that
there's
multiple
of
these
things
that
have
to
that
would
map
to
the
same
symbol
and
the
symbol
doesn't
map
back
to
any
one
of
them.
C
Well,
that
would
be
up
to
you
right.
If,
if
your
equivalence
class
is
that
all
distinct
values,
all
value
distinctions
are
relevant,
then
you
always
get
a
different
symbol
for
a
different
input,
but
if,
for
instance,
negative
zero
and
positive
zero
should
be
treated
equivalently,
then
you
would
ignore
the
distinction
in
the
process
that
maps
from
data
structure
to
symbol
and
there
and
in
the
reverse,
as
well.
B
The
reverse
is
the
thing
I
have
a
problem
with
the
if
you
ever
look
up
one
of
these
things
from
the
symbol,
you're.
Looking
up
one
of
the
many
elements
of
the
equivalence
class,
which
are
observably
distinction.
C
B
B
C
B
So
this
criteria
that
that
we
talked
about
about
the
separation.
B
Well,
that's
the
that's
the
place
where
we
in
this
group
were
very
much
leveraging
the
anticipated
existence
of
records
and
tuples
and
the
in
terms
of
the
multi-role
world
in
order
to
have
a
separation
and
enforce
separation
between
the
realms,
but
still
be
able
to
build
membranes.
Pleasantly.
B
Peter's
observation,
of
course,
only
applies
for
interagent
communication
within
one
realm.
It
doesn't
help
communicating
between
realms
and
frozen
objects,
of
course,
can't
be
directly
communicated
without
breaching
the
object
graph
isolation,
separation
according
to
the
force.
So
so
that's
the
place
where
I
don't
know
how
to
recover
from
loss
of
records
and
tubals.
D
D
Almost
three
years
ago
we
were
thinking
hey.
It
might
be
a
good
idea
to
present
membranes
as
something
to
actually
add
in
to
tc39
or
I'm
sorry,
ecma
262,
simply
because
of
the
complexity
of
implementing
them.
A
Well,
in
particular,
if
membranes
are
supported
as
part
of
the
languages
first
class
attraction,
it's
conceivable
to
me
that
some
of
the
hoops
we've
had
to
jump
through
to
to
to
do
it
from
the
outside,
in
particular,
some
of
the
things
which
are
obstructions
to
membrane
transparency,
which
could
be
overcome
if
you're
in
cahoots
with
the
javascript
implementation
might
be
attractive.
And
then
the
question
is
you
know
what
are
those
things.
B
If
you
can't
do
it
at
the
user
level,
using
proxies
and
weak
maps,
then
if
you
do
it
at
the
language
law,
if
somehow
you
do
at
the
language
level,
something
you
couldn't
do
at
the
user
level,
then
you've
introduced
new
abilities
that
somehow
violate
the
semantics
of
the
limitations
we
currently
have,
and
I
think
that
the.
A
Right,
I
mean
I'm,
I
was
thinking
of
you-
know
weak
refs
as
an
example
of
something
which
which
you
could
not
implement
in
the
language.
A
B
It's
certainly
worth
looking
for
altogether.
I'm
skeptical
proxies
and
weak
maps
were
introduced
in
order
to
enable
membranes
to
be
built
as
transparently
as
possible
at
the
user
level,
and
it's
apparently
possible,
while
still
maintaining
good
security
properties
and
all
that
and
the
various
attempts
to.
A
Well,
I
I
mean
I'm
membranes
are
something
I
only
have
kind
of
a
finger
fingernails
grasp
understanding
of
some
of
the
subtleties,
and
so
you
know
take
that.
Take
that,
for
you
know
as
a
as
a
disclaimer,
but
I
guess
with
with
membrane
non-transparency.
A
Some
of
the
non-transparencies
are
implementation,
artifacts
that
are
just
annoying
and
some
of
them
are
in
some
sense,
they're
features,
they're
they're
the
things,
the
very
things
that
are
the
the
reason
why
you,
you
want
to
have
a
a
membrane
and
not
just
pass
the
object
through
directly
that
there's
some
some
actual
some
some
barrier.
You
know,
there's
the
distortion,
that's
happening,
which
is,
by
definition,
not
transparent,
and
so
I
don't
know
that
we
have
a
clean
explication
of
the
the
differentiation
between
these
two
categories.
B
We
do
the
the
only
barrier
between
a
membrane
between
realms,
acting
like
a
direct
realm
boundary
other
than
incredibly
obscure
edge
cases,
we'll
get
back
to
the
edge
cases
in
a
moment,
but
other
than
the
incredibly
secure
edge
cases.
B
The
only
barrier
we've
got
is
that
internal
slots
and
the
built-in
methods
that
recognize
them
recognize
the
internal
slots
across
realms,
whereas
they
cannot
recognize
the
internal
slots
across
a
membrane
across
realms
or
across
a
membrane
period,
because
there's
no
secure
theory
for
doing
that,
and
the
thing
that
retroactively,
if
we
could
change
in
the
language,
would
simply
repair.
The
problem
is
to
say
that
that
internal
slots
and
the
methods
that
recognize
them
are
all
per
realm
and
there's
no
cross
realm
recognition
of
internal
slots.
B
What
happens
if
you
leave
off
the
third
argument,
which
is
the
the
constructor
from
which
to
get
the
prototype
to
grant
as
the
prototype
of
the
newly
constructed
object
when
gorick's
early
realm
shim
was
breached
by
xmelia
h?
B
If
the
problem
is
that,
once
the
spec
accident
was
faithfully
implemented
by
all
the
major
engines,
it
was
no
longer
something
we
could
back
out
of,
and
there
was
also
a
weird
thing
that
xmlh
leverage,
which
I
think
is
not
a
spec
accident.
But
it's
certainly
bizarre,
which
is
when
you
build
the
membrane
and
you're
doing
things
like
triple
equals
to
gather
the
arguments
that.
B
B
Yes,
yes
triple
dot
and
when
you're
doing
triple
dots
to
yeah
and
it's
the
arrays,
it's
the
iterators,
so
there's
ways
to
to
to
abuse
the
so
so.
Basically
you
had
to
build
the
member
build
the
mechanism
where
you
you
try
to
rigorously
avoid
any
use
of
triple
dot
and
rigorously
audit.
All
the
uses
that
you
do
thinking
in
terms
of
how
triple
dot
is
implicitly
calling
on
user
overrideable,
iteration
behavior.
B
Yeah,
but
I
mean
this-
this
is
the
kind
this
once
you've
reduced
the
internal
slot
once
you've
waved
a
magic
wand
made
the
internal
slot
problem
go
away.
These
are
the
remaining
anomalies,
so
you've
really
reduced
it
down
to
something
that
for
a
you
know,.
D
D
I'm
wondering
if
it's
I'm
thinking.
One
of
the
issues
we
would
need
to
raise
is
where
do
membranes
fit
in
the
ecma
space?
Do
they
belong
in
the
main
specification?
D
B
So
let
me
let
me
state
a
position
here,
which
is
the
first
place
they
should
show
up
formally
in
ecma.
262
is
as
a
high-level
invariant
using
you
know,
leveraging
yulia's
initiative
providing
its
estate
invariance
normatively
in
the
spec.
There
should
be
a
normative
statement
that
membranes
must
remain
implementable,
both
securely
and
with
the
level
of
of
practical
transparency
that
they
currently
have
and
with
their
ability
to
support
distortability
that
all
of
those
requirements
should
be
stated
normatively
so
that
anything,
that's
that's
proposed
that
would
cause
future
membranes
to
lose.
B
Any
of
those
properties
can
be
flagged
as
violating
a
normative
invariant.
I
think
that's
the
first
place
they
should
show
up
next
place.
They
should
show
up.
Is
integration
testing
in
test
262,
which
is
not
the
262
spec,
but
as
part
of
the
overall
tc39
process,
then
example,
membranes
can
certainly
be
will
certainly
be
present
in
those
integration
tests
and
then,
I
think,
there's
a
longer
term
process
of
experimenting
with
parameter.
B
D
That
was
a
lot.
We
have
to
review
the
notes
to
capture
all
that
mark.
D
I
don't
have
an
argument
per
se
but,
like
I
said,
the
main
goal
of
what
of
this
agenda
item
that
I
brought
up
was:
can
we
at
least
establish
a
place
in
github
where
we
can
say
okay,
we're
going
to
write
this
article
for
tc39
to
consider-
and
it
mainly
is
a
a
written
gathering
point
for
all
the
issues
that
we
think
are
going
to
come
up
the
requirements?
Etcetera.
I
just
want
to
have
a
a
home
for
it.
I
guess,
is
the
best
way
to
put
it
something.
D
That's
vendor
neutral,
since
I
have
my
membrane:
salesforce
has
theirs
lava
moat
metamask.
They
are
they're
ever
it's
starting
to
actually
we're
starting
to
see
a
small
proliferation,
which
is
a
good
thing.
But
if
we
want
to
move
beyond
libraries,
that
can
only
do
partial
transparency
got
to
have
a.
We
got
to
have
a
home
to
discuss
it.
B
Yep
yep,
I
do
think
that
all
of
these
I
mean
I
am
very
hopeful,
but
I
I
do
think
that
arriving
at
a
single
parameterizable
membrane,
abstraction
that
will
that
can
serve
all
these
needs
is
is
going
to
be
a
a
significant.
B
You
know
significant
project,
that's
going
to
require
you
know,
but
I
do
think
that
there
all
these
things
have
enough
in
common
there's
sort
of
this
core
mechanism
that
that
they
all
must
have
in
common
that
I'm
very
hopeful
that
we
will
find
that
common
library,
abstraction
that
we
can
all
agree
on
such
that
we
can
all
build
our
particular
membranes
by
parameterizing.
It.
E
E
It's
just
like,
while
a
formal
proposal
in
a
very
even
if
it
is
very
sketchy
and
it's
not
complete
and
so
on,
but
a
formal
proposal
which
we
know
stage
zero
is
for
free
and
if,
if
you
think
that
we
want
to
attack
that,
from
the
high-level
perspective
high-level
api
perspective,
then
we
should
have
a
proposal,
a
simple
proposal
explaining
what
is
the
the
general
idea
and
what?
What
are
we
trying
to
achieve
with
that?
E
And
if
the
committee
is
interested
on
on
that
kind
of
topic
and
it's
okay
for
for
the
group
to
spend
time
on
it,
then
we
we
go
to
in
stage
one
and
then
we
go
from
there.
I'm
on
the
opinion
in
general,
on
the
opinion
that
it's
too
early
on
to
come
up
with
a
solution
for
membranes,
because
we
still
have
very
very
little
experience
on
membranes.
E
That's
my
opinion,
but
I
believe
there
are
some
smaller
actions
that
we
might
be
able
to
take
in
order
to
facilitate
the
creation
of
membranes,
and
maybe
that's
what
you're
talking
about.
Maybe
that's
really
what
this
is
about,
like
just
looking
for
how
can
we
make
it
easy
for
people
to
implement
the
membrane
in
user
land,
and
I
think
that
has
a
better
chance
than
than
a
high-level
api
for.
B
You
know,
membrane
abstraction
mechanism,
as
opposed
to
just
a
pattern
that
people
follow,
is
sort
of
the
last
step
of
my
roadmap,
and
everything
else
is
about
supporting
membrane
patterns
without
one
one
agreement
on
a
membrane
organization,
but
where
the
separation
mechanism
enforces
the
separation.
One
of
the
things
I
think
will
be
very
clarifying
is
when
we
rebuild
membranes
on
top
of
the
separation
mechanism
and
we
introduce
the
distortion
parameterization.
B
Is
that
means
that
the
the
only
distortions
we
can
express
are
distortions
that
don't
reach
separation,
which
I
think
will
be
very
clarifying.
I
think
that,
so
far
the
basic
membrane
has
been
enforcing
separation,
but
then
it's
allowed
assertions
where
the
where
a
bug
in
the
distortion
could
breach
the
separation
and
it'll
be
very
nice
to
be
constrained
not
to
be
able
to
express
such.
B
D
Nope,
the
only
thing
I
would
say
mark
is
that
you're
looking
at
the
details
a
little
more
closely
than
I
am
I'm
just
looking
for
a
a
place
where
we
can
hang
our
hats
online.
B
B
Yeah,
so
maybe
the
first
place
to
start
is
trying
to
write
up
the
high
level
invariant
of
what
we
mean
when
we
say
membranes
must
remain
possible
because
that's
the
thing
that
should
go
into
the
actual
ekma
spec
first
and
it's
the
you
know,
first
application
of
yulia's
whole
initiative
to
try
to
get
high
level
invariants
into
the
spec
and
as
an
invariant.
That's
writing
down
what
is
already
implicit
in
the
current
spec.
It's
not!
It's
not
normatively
changing
any
observable
property
in
the
current
spec.
B
It's
just
it's
just
it's
just
stating
more
of
it,
normatively
that
it
wouldn't
even
need
to
be
a
proposal
making
it
through
the
stages.
It
would
be
more
like
a
pr-
or
maybe
you
know-
maybe
maybe
this
serves
as
a
test
case
to
decide.
Do
we
need
something,
that's
more
formal
than
a
pr
but
less
formal
than
a
full
proposal,
making
it
through
the
stages
for
these
invariants.
C
This
that's
the
the
needs,
consensus,
treatment
right.
C
B
C
Like
the
ability
to
detect
to
deal
with
promises
in
a
different
way
that
actually
short
circuits
when
they
are
native
array.is
array
comes
to
mind,
and
I
think
there
are
a
few
other
examples.
Probably
they
all
resolve
around
internal
slots
one
way
or
another.
B
They
they
do
yeah
ray
dot
is
array
is
actually
the
one
that
is
transparent,
but
it's
transparent
because
of
the
special
case.
So
it
sort
of
stands
out.
C
C
So
basically,
I
think
the
form
that
I
imagine
it
would
be
that
this
is
this
is
the
goal.
These
are
the
constraints
imposed
upon
future
changes,
and
these
are
the
pre-existing
exceptions
that
cannot
be
addressed.
B
You
know
the
wonderful
thing
about
this
whole.
You
know
new
consensus
around
realms
that
we
need
an
enforced
separation
mechanism
between
realms,
because
the
the
leakage
of
trying
to
separate
yourself
is
is
too
hazardous.
B
I
think
that
that
makes
it
that
that
suddenly,
I
think,
will
make
it
very
vivid
to
people
why
this
this
fight
to
preserve
practical
transparency
has
been
so
important
because
you
know
suddenly,
with
the
separation
mechanism,
realms
separated
are
going
to
act
differently
than
direct
object,
object
contact
in
these
ways-
and
you
know
we
have
succeeded
at
preserving
practical
interim
programming
in
a
way
that's
preserved
across
this.
B
B
There
are
well,
it
does.
B
Else
has
anything
more
to
say
that
they
want
recorded,
and
you
know
the
recorded
meeting
has
wound
down.
Then
we
can
turn
off,
recording
and
ask
if
anybody
has
anything
to
say
with
the
recording
off.
Why
don't
we
go
ahead
and
do
that.