►
Description
TODO: ADD descrioption here
OpenFeature website: https://open-feature.github.io/
B
C
C
I
think
that's
probably
best
so
I'm
gonna,
I'm
gonna,
maybe
just
we'll
delay
five
minutes.
I'll
just
wait
in
the
other.
Zoom
call
like
it
seems
like
the
same
one.
A
consistent
link
was
put
everywhere,
except
for
my
initial
comment.
So
I
think
that
we're
gonna
get
more
people
here,
which
is,
is
not
the
one
I
put
in
my
initial
comment,
because
this
is
the
one
sent
out
on
social
media
and
stuff
like
that,
so
I'll,
just
I'll
just
be
in
the
other
one
to
make
sure
I'll
just
go
confirm.
D
That
you
need
to
like
have
like
an
extra
person
to
just
put
in
there
with
like
a
just
a
Post-It
note
on
the
webcam.
That's
the
zoom
link
written
you
know
is
zoom
allowed
actually
well
nevermind
I'm
gonna
like
meeting
forwarding
yeah,
that's
it
or
just
like
chat
which,
where,
when
you
join
the
meeting,
you
could
see
the
chat
that
happened
before
you
joined
the
meeting,
because
then
you
could
just
put
in
the
chat
like
go
to
this.
C
For
five
minutes,
just
just
yeah,
we'll
start
in
five
minutes.
Let
people
know
what's
going
on
just.
D
A
D
My
dad
hates
animals
and
cats
always
like
come
up
to
him.
They
just
know
that
he
hates
them.
It's
like.
D
Yeah
for
those
who
didn't
hear
just
now
so
Todd
sent
there's,
there
was
a
two
different
Zoom
links
that
were
sent
out
and
we're
in
the
best
one
we're
in
the
correct
one,
but
Todd
has
momentarily
stepped
out
to
the
other
Zoom
meeting
to
tell
people
in
that
Zoom
meeting
that.
A
D
While
we're
waiting,
I
have
a
very
targeted
comment,
I
think
you
just
left
a
GitHub
comment
on
one
of
these
things
and
you
said
I
think
generally,
with
sdks
at
Target
client
uis
developers
would
expect
the
flag
evaluation
methods
to
be
async
did.
B
C
Okay,
sorry,
but
a
little
bit
of
a
delay,
everyone
I'm
sure
people,
let
you
guys
know,
but
we
accidentally
had
a
duplicate
meeting.
Nobody
actually
showed
up
in
that
one.
So
I
think
everybody's,
probably
here
I
just
wanted
to
be
there
to
intercept
and
redirect
just
in
case,
but
I
did
end
that
meeting
for
everybody,
so
nobody
will
at
least
be
waiting
waiting
there.
C
C
C
There's
an
issue
in
the
spec
repo
called
first
class
support
for
client
side.
I'll,
add
that
to
the
notes
and
and
that
kind
of
links
that
kind
of
links,
basically
to
all
the
the
relevant
opeps
I,
think
there's
three
and
it
links
to
I
believe
it
links
to
the
spec.
C
The
proposed
spec
changes.
If
it
doesn't,
we
can
add
that
yeah
I'll
I'll
have
that
and
also
directly
linked
to
that
too.
So
there's
a
PRI
open,
that
is
a
draft,
are
kind
of
a
collection
of
all
the
conclusions
I've
made
so
far
based
on
some
of
our
investigation.
So
that's
the
pull
request
that
I've
now
added
to
the
doc
that
and
I
don't
want
anybody
to
get
the
impression
that
that
pull
request
represents
anything
that
we
actually
have
to
do
like
that.
C
It's
set
in
stone
or
that's
the
direction
we're
heading
in,
but
I
wanted
to
to
keep
the
conversation
going.
So
it
was
more
or
less
to
start
discussion
to
have
actually
something
to
look
at
and
hook
holes
in,
but
yeah,
so
so
I
I'll
try
and
summarize
what
what
we
have
in
there
really
quickly.
So
there's
three
main
main
things.
C
So
one
is
shutdown
which
I
think
we
all
agree
and
have
agreed
for
a
while
that
we
need
so
a
way
to
basically
signal
to
the
API
that
the
provider
needs
to
be
shut
down.
This
is
especially
relevant
for
the
client,
because
a
lot
of
the
times
you
know
there's
polling,
setup
or
or
persistent
connection
setup.
It's
also
relevant
on
the
server.
C
So
we
need
to
clean
those
things
up.
I
think
it's
it's
something
we
need
in
the
spec
for
for
both
server
and
client,
but
it's
particularly
relevant
for
client.
The
next
one
is
events,
so
this
is
kind
of
related
to
shutdown
being
able
to
push
events
to
the
to
the
provider
from
the
back
end
right,
so
a
flag
state
has
changed
a
flag.
Configuration
has
changed
signal
to
the
to
the
SDK
through
the
provider
that
some
changes
occurred
and
allow
people
to
take
action.
D
On
that,
the
events
piece
I
think
it's
more,
even
if
it
wasn't
about
pushing
stuff
from
server
to
client,
even
if
it
was
just
about
like
giving
the
client
a
way
of
knowing
that
the
evaluation
is
completed,
I
think
it's
still
necessary.
So,
like
just
I,
don't
know,
I
think
it's
more
than
just
kind
of
real-time
kind
of
streaming
type
stuff
right.
C
D
Yeah,
like
yes,
yeah,
because
if
we're
yeah
I'm
sure
we'll
get
into
this
in
a
lot
more,
but
like
specifically,
what
I'm
thinking
about
if
I'm
building
like
a
react,
react
app
I
need
to
be
able
like
if
the
evaluation,
if
the
flag
valuation
is
a
synchronous,
call,
then
I
need
some
way
of
like
telling
react
to
like
re-render,
so
I
need
some
kind
of
event
or
trigger
that
says.
D
C
I
think
you're
right,
that's
a
good
point
that
that
is
that
is
kind
of
mentioned
in
in
the
offep
I.
Think
that's
that's
covered,
but
it's
a
good
thing
to
specifically
mention
yeah
I
I
agree
with
you.
That's
particularly
important
to
the
client
as
well
and
I.
Think
the
last
of
the
three
would
be
probably
the
most
controversial
is
changes
in
the
interfaces
to
support
basically
a
single
Global
context.
C
That's
more
or
less
I,
don't
want
to
say
static,
but
it's
static-ish.
So
it's
a
context,
that's
maintained!
That
represents
the
user
or
the
application
or
whatever,
and
then
some
kind
of
method
to
to
signal
to
the
underlying
provider
that
hey
that
my
context
has
changed,
perform
whatever
bulk
reevaluation.
You
need
to
do
so.
You
can
then
update
the
cache
of
flags
and
pull
flag
flag
values
from
it.
So
that's
probably
the
most
controversial
one
I
hope,
you're
I,
hope.
C
That's
somewhat
clear
and
I
will
comment
more
on
on.
Why
I
think
those
are
necessary
for
now
I
just
wanted
to
kind
of
open
it
up
for
high
level
comments
from
people
on
on
what's
been
proposed
so
far,.
B
So
my
thoughts
were
that
it
feels
like
the
it
feels
like.
The
first
decision
that
needs
to
be
made
is
whether
that
there's
a
single
SDK
or
whether
there's
two,
because
if
there's
two,
you
can
design
convention
for
each
one
based
on
the
use
case.
But
if
there's,
if
there's
just
one,
then
there's
a
lot
more
configuration
about
yeah
like
the
networking
model,
the
synchronous
or
asynchronous
nature
of
the
events.
You
know
a
bunch
of
other
stuff.
D
I
mean:
do
you
mean
you're,
not
I,
mean
I,
think
there's
a
distinction
between
just
like
the
the
artifact
like.
Do
we
distribute
just
like
one
SDK
versus
like
your
client
SDK
and
a
server
SDK,
I
kind
of
feel
like
that's,
we've
got
to
figure
that
out,
but
I
think
that's
less
critical,
but
I.
Guess
like
what
you're
part
of
what
you're
saying
is
like
the
is
the
API
like?
D
Is
there
a
single
API
that
supports
both
kind
of
paradigms,
or
do
we
need
to
just
have
do
we
have
like
two
similar
but
but
distinct
apis
that
aren't
shared
and
there's
no
shared
interfaces?
Or
do
we
have
like
a
big
API
that
kind
of
like
operates
into
different
modes
depending
on
which
providers
have
been
plugged
in.
B
B
What's
going
on
under
the
covers
and
how
it's
actually
working-
and
why
is
you
know
it
triggering
thousands
of
network
requests?
You
know
because
it
hasn't
been
set
up
to
run
in
a
single
context,
mode
or
whatever,
whereas
if
you've
got
a
Convention
of
that
with
a
client-side,
specific
SDK,
all
those
things
can
be
implicit
that
you
could
maybe
override,
or
maybe
the
provider
could
do
that.
So
maybe
the
when
you,
you
know
initialize
the
provider.
B
E
C
And
I
would
say
on
top
of
good
defaults,
though
that's
one
one
of
one
of
them
is
an
API
and
types
that
kind
of
push
users
into
the
right
usage
pattern
right.
Yeah,
that's
definitely
a
concern.
I
have
too,
though,
though,
I
should
say:
I
I
would
love
to
find
an
elegant
solution
that
that
supports
the
Paradigm,
I'm
kind
of
describing
for
single
context
mode
with
a
single
interface.
I.
Just
don't
know
if
it's
possible
I'm,
not
sure
I
I
would
love
for
it
to
be
possible,
but
I
suspect
it's
not.
D
And
you
mentioned
in
one
of
the
in
I
think
in
the
spec
change
you
kind
of
mentioned
at
one
point
that
in
theory,
if
you're,
if
you're
supporting,
if
we
had
like
a
I,
could
get
the
words
mixed
up.
If
we
had
the
multi-context,
if
we
had
support
for
multi-contacts,
then
like
a
multi,
a
multi-context
provider,
I'm
just
going
to
say
server,
side
and
client
side,
because
I
can't
get
it
around
my
head.
D
If
you,
if
we,
if
we
had
something
that
implemented
server
side,
then
we
could
like
essentially
adapt
that
into
like.
If
we
had
like
a
server-side
provider,
we
could
essentially
adapt
it
into
a
client-side
provider,
or
maybe
it's
the
other
way
around
like
in
theory.
We
could
just
do
the
caching
part
as
part
of
our
SDK
and
then
like
so
if
I'm
flagged
with
I
could
just
provide
the
if
I
provided
the
the
server
side
provider.
D
Where
you
give
me
the
context
every
time,
then
we
could
essentially
build
a
support
for
like
a
client-side
version.
It
would
just
be
that,
like
the
open
feature,
SDK
would
be
more
than
just
like
a
little
adapter
layer.
It
would
be
actually
doing
like
tracking
State
and
caching
snag
valuation,
stuff
and
blah
blah
blah,
but
like
I
think
we
could
like
one
is
one
feels
like
a
super
set
of
the
other,
basically
but
I'm,
not
sure
I.
Don't
think
we
should
do
that
right.
C
Yeah
I
think
in
general
you
can
basically
fit
the
single
context
Paradigm
into
a
multi-context
paradigm.
Like
you
can
you
can
you
can
make
the
multi-contacts
behave
like
a
single
one
from
from
an
implementation
perspective?
Yeah,
it's
that
you
don't
want
to
expose
those.
The
massive
I
think
the
massive
foot
guns
that
Ben
is
describing
right
are
what
I
don't
want
to
expose
our
application
authors
to.
So
it's
just
it's
basically
a
matter
of
hiding
those
but.
D
That's
I
mean,
but
that's
like
that
side
of
of
open
feature
like
the
the
side
that
the
application
offers
see
is
like
almost
distinct
right
like
like
you
could
have
two
totally
different
apis
like
a
client-side
API
and
a
server
side
API
for
application
offers,
but
still
like
a
single
provider
that
then
we're
kind
of
like
like
on
the
you
know.
On
the
provider
side
we
have
like
a
universal
thing:
I,
don't
think
we
should
I.
D
D
Think
none
of
no
one's
going
to
want
I,
don't
think
any
established
feature
flag
provider
is
going
to
want
to
do
this
Universal
thing
because
I
think
it
it's
like
it's
just
it
takes
it's
open
features
doing
too
much
basically
and
like
it
would
change
the
semantics.
Inevitably,
it
would
change
the
semantics
of
how
client-side
feature
flagging
worked
if
we
tried
to
adapt
to
server-side
feature
flagging
thing
on
behalf
of
one
of
those
providers.
C
Yeah
but
I
think
your
point
is
a
good
one
about
the
API,
like
one
of
the
things,
for
instance,
that
open
Telemetry
does
is
they
bundle
their
API
and
SDK
separately,
so
so
the
API,
the
application,
others
Target
is
one
artifact
and
then
the
SDK.
That
kind
of
you
write
Integrations
against,
is
a
separate,
artifact,
yeah
and,
and
that
and
I
think
it's
probably
more
reasonable
for
us
to
introduce
a
single
SDK
to
write
providers
that
probably
could
be
implemented
as
a
single
set
of
interfaces,
but
ship
like
a
two
apis,
one
API.
C
That
would
be
the
single
context,
one
that
would
be
multi
context.
I
think
that
could
hypothetically
work
I,
don't
know
that
we
even
would
need
to
do
it
that
way.
Right
now,
but
yeah,
I,
I,
think
that
could
work
and
I
think
there's
other
benefits
to
doing
that
like
one
of
them
is
third
party
inclusion
of
the
API.
You
know
if
you're
building,
if
you're,
if
you're,
building
an
orm-
and
you
want
to
include
open
feature
API
in
it,
you
can
just
include
the
API
and
none
of
the
artifacts
related
to
sdks.
A
D
I
I
think
I
think
the
most
important
decision,
like
one
of
the
most
important
things
about
how
we
decide
to
do
this,
is
like
the
developer
kind
of
like
ergonomics
and
I.
Think
we
just
need
to
remember
that
a
someone
implementing
the
provider
is
it's
almost
literally
like
their
their
job.
To
understand
how
open
feature
works
is
part
of
implementing
that
provider.
Assuming
open
feature
is,
like
you
know,
super
successful
on
the
application
offer
side.
This
is
literally.
The
last
thing
they
want
to
understand
is
like
how
open
Future
Works
and
like
so.
D
We
we
can
confidently.
I
would
say
confidently
assume
that
if
there
are
any
foot
guns
implemented
on
that
that
application
officer
side,
people
will
pick
them
up
and
and
shoot
them
a
lot.
So
I
think
we
I
think
it's
worth
just
doing
a
lot
to
like
make
it
super
easy,
because
that's
been
one
of
my
experience
like
one
of
my
experiences
of
open,
Telemetry
and
I,
wouldn't
fall
open
time.
Would
you
hear
I
think
it's
just
inherently
essentially
complex
thing
but
like
as
someone
who
just
wants
to
instrument
things?
D
E
Just
said
is
a
something
that
needs
to
be
written
down,
like
that's
a
value
of
the
project
that
I
agree
with,
which
is
we
preference
the
end
user
of
feature
Flags
over
the
experience
of
Provider
authors?
Obviously,
we
want
to
make
it
good
for
both,
but
if
a
decision
has
to
be
made,
we
will
preference
the
end
user
over
yeah.
D
F
F
F
B
Some
of
them
are
implicit
in
the
language
that
you're
working
on,
or
you
know
if
you're
writing
a
user
interface
rather
than
the
server-side
rendered
page
or
something,
but
there's
no
established
sort
of
standard
Behavior
across
a
lot
of
the
different
products
and
platforms
that
are
out
there
and
people
come
at
these
SD,
our
sdks,
with
like
very
radically
different
expectations
or
assumptions
about
how
they
work
and
then,
when
you
explain
to
them
like
how
it
works,
which
you
know,
because
people
don't
read
the
documentation
right
and
then
they're
like
oh
I,
didn't
realize
it
does.
B
You
know
something
completely
different
completely
different
to
how
I
expect
I
would
have
expected
it
to
work
so
yeah
that
that
and
it's
difficult
because
you
know
people
think.
Oh,
it's
just
it's
just
Flags,
just
a
Boolean,
but
actually
you
know
there's
there's.
Actually
a
lot
of
you
know
potential
complexity
in
in
especially
around
manage
dealing
with
latency,
networking
and
stuff
like
that.
A
B
Like
and
you
know
whether
we
might
need
whether
we
might
need
to
sort
of
surface
these
different
behaviors
as
like
first-class
citizens
of
like
this,
is
the
launch?
Darkly
go
provider
it.
You
know,
I
mean
I
kind
of
don't
like
these
matrices,
but
it's
like
you
know
it
does
store
its
state,
it
does
store
flag
State
and
it
does
do
this
and
it
does
do
that.
I.
D
You
need
to
configure
the
SDK
with
a
provider
and
if
we're,
if
we're
comfortable
with
having
two
Standalone
apis
for
open
feature
overall,
like
the
client-side
one
and
the
server
side,
one
which
share
a
lot
of
similarities
but
are
kind
of
like
distinct,
then
you
can't
like
it
you.
It
isn't
really
going
to
be
possible
for
someone
to
like
accidentally
plug
in,
like
a
client-side
provider
to
a
server
side
like
I.
Think
I.
Don't
think
that
I.
D
Don't
think
that
part
is
that
controversial,
like
I,
think
I
think
we
probably
would
all
agree
that,
like
we're
not
gonna,
somehow
I
I,
I
I
was
very
hopeful.
We
could
do
it,
but,
like
I'm
I,
think
also
very
naive,
like
we're
not
going
to
somehow
create
some
kind
of
universal
provider
API
that
would
work
so
I
think
we
should
embrace
that
and
say
that
there's
two
distinct
interfaces
that
you
need
to
implement
for,
like
client-side,
I'm,
a
client-side
provider,
I'm
a
server
side
provider
and
and
then
on
the
other
side.
D
I.
Think.
Probably
what
we're
getting
to
saying
is
that
we
wouldn't
have
like
a
shared
interface
on
the
application
author
side
on
the
evaluation
side.
We'd
have
two
distinct
interfaces.
I
think!
That's!
That's
something!
I
want
to
kind
of
prod.
You
on
Todd
is
like
I
think
in
the
I'm,
not
clear
from
reading
the
spec,
whether
because
it's
kind
of
spec
language,
do
you
see
this
as
being
like
in
in
an
implementation
of
the
spec?
D
Do
you
see
this
as
being
like
a
like
a
a
single
interface
where,
like
there's
just
like
a
client
interface
or
would
it
be
like
separated
where,
like
I,
can
get
like
a
client-side
interface
or
a
server-side
interface
as
an
application
author
or
someone
or
an
application
integrator
not
on
the
provider
side,
but
on
the
the
other
side,
you're.
C
Are
you
you're
asking
just
to
make
sure
I'm
understanding
you're
asking?
Would
there
be
some
kind
of
factory
method
where
you
would
generate
basically
one
interface
of
the
other
or
versus?
Would
it
just
be
a
published
artifact
that
only
contains
the
the
one
interface?
Is
that
kind
of
what
you're
asking
yeah.
D
Well,
I
mean
you
could
go
as
far
as
it's
literally
like
one
interface,
but
like
half
of
the
methods,
don't
make
sense
to
call
right
like
if
you
want
to
go
really
on
that,
like
on
one
extreme.
It's
like
it's
impossible,
there's
just
literally
like
there's
a
an
artifact
that
only
has
one
interface
On
The,
Other
Extreme.
You
have
a
single
interface
where,
like
some
of
the
methods,
don't
make
sense
to
call
if
you
haven't
plugged
in
the
right
provider
and.
F
D
Agree
particularly
if
it
particularly
like,
if
it's
something
where
you
call
it
at
boot,
and
it
fails
I,
think
that's
okay,
because
we
can
fail
fast
and
like
blow
up
and
it's
pretty
clear,
what's
happened.
But
if
it's
like
at
the
point
that
I
evaluate
flag
and
there's
like
one
like
some
like
screen
in
the
application,
that's
accidentally
misconfigured
and
it-
and
it
fails
like
at
that
point
because
because,
like
you,
use
the
wrong
version
of
the
wrong
Paradigm
I
think
that
would
be
really
really
bad.
C
Yeah
I
I,
so
my
feeling
I
mean
I,
don't
want
to
get
too
far
ahead
of
ourselves
here.
My
feeling,
though,
is
that
there
would
be
separate,
published
artifacts
to
to
remove
all
those
foot
guns,
so
you
would
JavaScript
is
probably
the
easiest
example
to
think
about.
I
mean,
like
I,
said
in
a
thread
earlier
today,
in
slack
I'm,
not
even
sure
we
would
Implement
a
client-side
Java
version.
You
know
we
might
Implement
a
kotlin
one.
C
Probably
we
wouldn't
Implement
like
a
net
one
like
I,
don't
know
what,
where
the
demand
would
be
I,
don't
think
would
be
super
high,
but
for
for
JavaScript
you
can
easily
see
well.
You'd
want
a
node
version
and
you'd
want
a
web
version.
So
I
would
say
you
know
like
it
would
end
up.
Looking
like
here
is
the
here
is
the
open
feature
web
SDK
and
it
looks
a
lot
like
the
JavaScript
one.
In
fact,
maybe
it
even
shares
some
code
with
it
from
like
a
third,
a
third.
C
You
know
Base
Library
or
something
not
super
important,
but
it
has
different
interfaces
to
the
application
author
and
it's
a
separate,
published
artifact,
and
it
can't
even
you
know,
be
yeah
it
it.
That's
that's
what
you
would
kind
of
use
on
the
web.
C
Perhaps
it's
even
bundled
and
shipped
in
a
way
that
makes
sense
for
for
that
yeah.
That's
that's.
How
I
see
it
but
I
think
one
thing
I
I
really
like
to
to
get
out
of
this
meeting
is,
if
there's,
if
there's,
if
there's
opinions,
that
this
is
kind
of
the
wrong
route
that
that
we
need
to
think
differently
in
terms
of
the
multiple
interfaces
I'd
like
to
I
like
to
poke
holes
in
that
theory,
so
I'd
like
to
test
it
against.
C
You
know
against
criticism,
because
I
I
kind
of
think
based
on
based
on
especially
like
the
the
you
know,
Pete
and
I
had
some
meetings
with
we
had
meetings
with
launched
Darkly
we
had
meetings
with
I
think
you
had
a
meeting
with
Thomas
from
go
feature
flag.
We
also
talked
to
Spotify
a
lot
of.
Oh
you
didn't.
Okay,
we
talked
to
Spotify
and
and
I
think.
C
There's
there's
definitely
a
lot
of
overlap
between
what
Spotify
was
doing
and
and
kind
of
The
Proposal,
but
I
want
to
make
sure
that
you
know
that
we're
not
just
blindly
choosing
this
Avenue
if
there's
other
options
so
I'd
like
to
make
sure
that
we've
got
those
ideas
out
and
poke
holes
in
this
as
much
as
possible.
Before.
D
D
Not
right
now,
but
like
maybe
in
a
few
minutes,
I'd
like
I,
definitely
want
to
talk
about
the
evaluation
context
and
and
kind
of
like
how
that's
used
but
but
but
I
think
you're
I
mean
you.
You
should
continue
to
ask
or
try
and
get
feedback
from
everyone
on
the
call
here
about
that.
Just
the
overall,
my.
E
My
main
concern
with
the
split
of
sdks
is
the
maintenance
burden
of
having
to
own.
So
many
sdks,
like
I,
think
that
there's
a
real
risk
that
we
have
around
foreign
having
such
a
fragmented
number
of
sdks,
that
we
don't
have
the
support
to
get
them
to
be
good.
If
that
makes
sense
like
we
make
a
change
in
the
spec
and
now
okay,
we
have
70
sdks.
E
B
You
generally
only
be
that
the
only
the
only
examples
I
can
think
of
where
you
might
have
to
write
an
additional
SDK
would
be.
B
Maybe
JavaScript
and
Java
right,
there's,
like
maybe
flutter,
because
that
can
Target
web
I
don't
know
I,
don't
think
you'd
get
I.
Don't
think
that
would
because
what
what
we'll
be
saying
is
like
this
is
the
Swift
open
feature
SDK
and
it
it
it.
It
runs
in.
It
operates
in
client-side
mode.
It's
it's
a
client-side
SDK
right,
and
this
is
the
these
are
the
things
that
the
client-side
SDK
behaviors
have,
and
then
this
is
a
go
one,
and
these
are
the
server-side
behaviors
that
it
has
yeah
yeah.
C
Unless
Google
becomes
a
very
popular
language
on
on
Android
or
something
at
some
point,
I'm
not
sure
that
that
will
and
yeah
it'll
be
something
that
we
we
have
to
worry
about,
I
think
to
Justin's
point.
It
does
mean
a
little
bit
more
work
like
there
would
there
would,
at
least
in
the
case
of
JavaScript,
maybe
in
the
case
of
java,
if
you
want
to
support
a
Java,
Android
version,
so
I
think
there
is,
is
some
more
work.
It's
certainly
not
doubling
our
sdks,
though,
to
to
what
to
your
point,
Ben
and.
B
We
and
we
did-
we
did
go
down
the
single
SDK
route
for
like
for
Java
and
JavaScript
I
think,
but
that
was
I
mean
purely
because
there
was
like
no,
no,
what
no
one
really
working
on
those.
We
didn't
have
much
people,
many
people
working
on
it,
but
we
fairly
quickly
realized
that
yeah
we
had.
We
had
to
just
take
on
the
additional
burden
of
splitting
them
out
and
having
two
more
to
work
on
and
two
more,
you
know
going
from
10
to
12
or
whatever,
but
I
think,
okay,
I.
B
F
F
I
think
that's
also
what
leads
us
to
context
I
think
there's
also
security
concerns
to
some
extent,
so
I
think
we
should
list
the
reasons
as
part
of
it
as
it
doesn't
proposed
before
we
should
document
why
we
take
decisions
which
would
also
take
decisions
that
Thrive
while
we're
doing
this,
because
it
will
come
up
most
like
they
can
at
some
point
later
in
time,
it's
totally
different,
runtime,
totally
different
characteristics.
The
way
it's
used.
F
And
I
mean
it
could
even
argue
like.
Is
there
really
a
use
case
for
multiple
contexts
in
the
web?
That.
D
There
is
I
mean
that
we
it's
not
the
exact
exactly
the
same,
but
there's
definitely
there's
definitely:
scenarios
they're
kind
of
more
advanced
scenarios,
I
think,
but
there's
definitely
scenarios
like
when
we
were
talking
to
Spotify
they.
They
had
a
few
examples
where
the
context
is
more
Dynamic,
I,
wouldn't
say
it's
as
dynamic
as
like.
D
A
web
server
where
literally
like
every
request
is
like
is
new,
but
they
they
like
I,
think
so
an
example
that
that
they
gave,
which
I
thought
was
really
interesting,
is
if
you've
got
a
feature
flag
where
the
decision
depends
on
which
artist
you're
looking
at
so
like
if
they're
doing
an
A,
B
test
and
they're
they're
kind
of
like
bucketing
on
artists.
Now
every
screen
I
go
to
is
potentially
a
different,
there's,
a
potentially
different
context.
D
In
fact,
potentially,
if
it's
like
a
list
of
search
results,
it
could
be
like
the
feature
flag
is
going
to
vary
for
every
like
magical
and
everything.
That
would
actually
be
the
case
but
like,
but
it's
it's
an
example
of
where,
if
you're
really
really,
if
you're
using
feature
Flags
in
more
in
like
a
product
development
sense
than
like
a
devopsy
sense
right
like
where
you're
actually
doing
like
a
b
testing
Etc,
then
the
context
becomes
much
more
subtle.
There's
like
loads,
more
kind
of
like
subtleties
and
more
use
cases
in
there.
D
I
think
so
this
is
the
the
main
thing
that
I
the
main
question
I've
got
I.
Think
the
biggest
question
I've
got
with
the
kind
of
current
proposal
is
the
idea
that,
when
you're
in
client-side
mode
there's
just
one
shared
Global
context
that
I
worry
that
that
boxes
Us
in
at
2.0
was
about
like
kind
of
like
changing
out
changing
our
Direction
in
the
future.
I
think
that's
going
to
make
it
I'm,
worried.
D
I,
haven't
fought
it
through
entirely,
but
I'm
worried
that
it
will
make
it
harder
for
us
to
course
correct
in
the
future
and
say:
oh
actually,
it
makes
sense
to
be
able
to
Nest
or
kind
of
like
have
layers
of
of
context
and
I'm
also
kind
of
worried
that
it'll
make
it
hard
for
some
providers
to
actually
you
know,
I,
don't
think
I'll
make
it
hard
for
providers
to
support
it,
but
yeah
I
mean
that's.
That's
the
biggest
kind
of
concern
I
have
with
the
proposal
as
it
is
right
now.
C
So
specifically,
with
the
Spotify
example,
I
mean
and
and
any
anybody
who's
a
member
of
the
organ
and
really
wants
to
hear
that
discussion
like
I,
said
it's
recorded.
If
you'd
like
me
to
send
it
to
you,
as
I
said
before,
I
don't
want
to
broadcast
it,
but
they
they
made
it
clear
that
they
were
okay
if
we
recorded
it.
C
But
but
with
regards
to
that,
their
use
case
seemed
seemed
to
be
consistent
with
what
what
I
think
we
were
talking
about.
I
mean
it's
not
that
the
context
is
static
and
even
when,
even
when
they
were
describing
it,
they
were
talking
about
like
yeah
viewing
an
artist
or
whatever
it's
just
that
there's
basically
one
Global
one
and
they
were
kind
of
talking
about
enhancing,
like
adding
additional
data
to
to
that
context
which
yeah
we
currently
like.
We
currently
have
a
way
to
do
that
in
the
in
the
proposed
spec.
C
So
in
fact,
that's
like
what
the
point
of
like
the
set
context.
Hook
is
right
to
say.
Okay,
my
contacts
has
changed.
Let's
do
a
reevaluation
I
think
what
it
sounds
like
when
I
heard
spotify's
use
cases
we
don't
necessarily
want
to
bulk
reevaluate
everything
based
on
that,
maybe
just
just
scope
it
to
a
certain
set
of
flags
or
something
which
I
yeah
I
think
that's
worth
thinking
about,
but
I,
don't
I,
yeah
I
think
we
should
think
about
that.
C
We
could
spend
some
time
thinking
and
talking
about
it
and
maybe
even
asynchronous
synchronously
is
better.
Let's
see
what
parts
how
we
can
improve
the
API
to
kind
of
support
that,
like
a
partial
update
or
something
like
that
too
yeah
to
the
to
the
the
the
cached
Flags
but
I,
don't
think
that's
a
fundamental
I,
don't
think
it's
fundamentally
in
opposition
with
kind
of
what
what
we
have
proposed
so
far.
I
could
be
wrong
about
that.
D
So
it's
also
kind
of
like
an
opportunity
to
like
take
a
step
back
and
see
if
there's
something
else,
we
want
to
shift
at
the
same
time.
The
thing
that
I
keep
on
thinking
about
is
like
the
the
kind
of
the
the
semantics
we
have
at
the
moment,
where
there's
this
kind
of
like
Global
set
of
State
and
then
there's
this
kind
of
client
and
then
there's
and
then
there's
like
the
per
evaluation.
D
So
there's
different
kind
of
Scopes,
right
and
and
I'm
not
like
the
client
at
the
moment,
is
like
feels
a
little
bit
to
me
like
this,
like
this
kind
of
like
it's
kind
of
like,
has
some
kind
of
state.
It's
kind
of
stateful
kind
of,
and
so
you
could
kind
of
use
it
for
doing
this
best
conferencing.
But
it's
not
exactly
like
there's
some
stuff
that
you
only
do
on
the
on
the
kind
of
like
with
the
Singleton,
so
like
I
kind
of
I.
D
Think
it's
worth
us
taking
some
time
to
think
about
whether
we
could
kind
of
push
that
one
way
or
the
other
and
just
say
for
you
know
like
either
either
like
almost
everything
is
all
of
the
stateful
kind
of
stuff
like
cached,
Flags
or,
like
you
know,
pre-evaluated
Flags
is
is
in
this,
the
per
client
scope
or,
alternatively,
we
get
rid
of
that
client
concept,
which
I
think
is
really
confusing
for
someone
I
think
it's
really
confusing
that
I
found
it
confusing,
because
I
kind
of
assumed
that
I
was
creating
a
client
for
a
reason.
D
But
at
the
moment,
in
the
context
of
like
client-side
Flags,
the
client
is
kind
of
like
doesn't
do
anything.
It's
just
like
confusing
me
because
I
don't
know
whether
I
should
call
a
method
on
the
client
or
on
like
that
open
Future
kind
of
globalton,
so
I
kind
of
feel.
D
Like,
like
the
reason,
I
think
it's
worth
us
talking
through
in
more
detail
like
that
idea
of
the
evaluation
context
is
because
I
I
would
almost
argue
that,
if
we're
not
going
to
do
evaluation
context,
kind
of
scopey
type
stuff
with
a
client
I
would
say
we
just
get
rid
of
the
client
as
a
concept.
C
I'm,
not
I,
I,
see
your
point
and
I
think
I,
I
kind
of
I
kind
of
agree.
The
client
makes
a
lot
more
sense
in
the
server
like
one
of
the
main
uses
for
the
client
is
is
even
as
like
a
like
a
dependency
injection
Frameworks.
It's
a
really
good
Target
for
like
maintaining
State
across
right
across,
like
an
ioc
context.
Right.
D
But
that's
also
true,
like
that's
also
true
and
like
in
the
context
like
react,
for
example,
right
like
you
and
kind
of
like
inject
it
into
context
and
then
kind
of
grab
it
later
on
when
I
started.
Building
like
this
kind
of
experimental
react,
SDK
I
did
that
and
then
I
realized.
There
was
no
need
for
me
to
do
it
because
the
client
doesn't
do
anything
yeah.
C
D
Mean
I
think
it's
interesting
to
think
about
like
if
we
removed,
so
it's
going
to
have
a
different
interface
anyway,
on
the
on
the
on
the
client
side,
API
versus
the
server
side
API,
so
maybe
to
otherwise
this
point
of,
like
kind
of
not
kind
of
deferring
decisions
or
kind
of
like
leaving
our
options
open
and
not
making
stuff
in
like
this-
and
this
is
a
bit
of
a
weird
kind
of
kind
of
controversial
thing
to
say,
maybe
but
like
what,
if
we
just
didn't,
have
that
client
interface
for
client
there's
just
like
overloaded
words
didn't
have
that
client
interface
for
client-side
flags,
and
we
just
had
like
the
open
feature
kind
of
just
like
globalton
or
whatever,
depending
on
the
language,
and
that
leaves
us
the
option
in
the
future.
D
If
we
wanted
to
introduce
this
idea
of
kind
of
scoped,
nested
evaluation
context,
the
obvious
way
of
doing
that
would
be
to
reintroduce
some
kind
of
like
client
thing,
and
that's
where
you
would
do
your
your
nested
kind
of
like
set
some
context
on
this
specific
client
like
a
logger.
Does
right
like
or
something
like
that.
C
F
C
Of
the
things
that
it
potentially
could
open
up
is
the
possibility
of
even
having
those
same
methods
available
on
the
server
it
just
they
operate.
When
you
call
I
mean
it
seems
overloaded,
but
you
might
be
able
to
share
more
of
the
same
interfaces,
so
I
feel
like
that's
confusing,
probably
don't
need
to
yeah.
C
Okay,
so
so
I
think
I
think
the
two
the
two
main
takeaways
I'm
I'm
hearing
is:
we
need
to
think
about
maybe
how
to
maybe
how
to
support
a
more
robust
context,
update
context,
update
situation.
C
So
those
those
are
the
two
big
takeaways
I-
can
see
that
probably
probably
Merit
some
asynchronous
investigation
and
then
maybe
another
another
meeting,
or
at
least
some
ofeps
and
asynchronous
conversation
on
them.
D
I
think
it's
good
to
get
for
us
to
get
like
a
seems
like
a
pretty
solid
decision
on
just
like
the
the
that
really
big
thing
that
Ben
was
saying
of
just
like
you
know,
is
it
a
single
interface
or
a
single
API,
multiple
apis
that
stuff
I
think
is
it
feels
like
we've
got
at
least
from
the
people
that
were
talking
I,
think
we
got
some
agreement,
one
one
thing
I'm
worried
about
is
we
have
like
various
vendors
and
kind
of
Provider
implementers
like
we've
got
at
least
I
think
on
on
the
call
a
couple
here
and
I
think
that
it's
re
like
me
and
you
Todd,
particularly
like
we're
like
super
in
the
weeds
and
I'm
I'm,
guessing
it's
pretty
like
unless
you're
it's
pretty
hard
to
follow,
along
with
all
of
the
stuff
we're
describing
right
and
that's
not
because
we're
like
so
smart.
D
What
this
client
side
thing
would
look
like
in
like
in
a
really
nice
summary
that,
like
we
could
give
to
Adam
you're
a
Dev
cycle
right
yeah
like
so,
we
could
give
to
like
Adam
and
Ryan
and
Daniel,
and-
and
you
know,
the
Ben
and
like
the
all
of
the
the
kind
of
like
the
vendors
who
are
interested
and
just
get
get
like
us,
a
gut
checks
and
see
check
of
like
does
this
feel
like
this
is
a
does.
D
This
feel
like
this
is
something
that
would
work
for
you
to
implement
as
a
provider
like
to
implement
a
provider
for,
and
then
B
does.
This
feel
like
something
that
you
would
be
comfortable
providing
to
your
customers
as
like
a
as
a
as
an
API
right,
because
I
think
those
are
the
two
questions
that
we're
asking
for
for
providers
is
like.
Would
it
be
possible
for
you
to
build
this
SDK?
Is
this
gonna
like?
Are
there
some
serious
issues
here
and
then
also?
How
do
you
feel
about
this
interface?
Like?
Would
you
be?
D
D
So
yeah
I
feel
like
that's.
Another
thing
we
should
do
is
like
and
I
like
I
think.
That's
kind
of
just
we're
just
like
with
this
is
part
of
that
kind
of
evolution
to
go
there
right,
you've
kind
of
just
got
to
like
lay
out
a
bunch
of
stuff
and
then
kind
of
like
refine
it
a
little
bit
and
then
lay
it
out
and
then
eventually
get
it
to
the
point
that
we've
got
like
something.
D
F
D
I
would
much
rather
I
would
honestly
much
rather
get
negative
feedback
than
silence.
The
thing
that
worries
me,
the
most
is
that
we,
if
we're
not
Community,
if
we're
not
packaging,
this
up
in
a
way
that
kind
of
is,
is
consumable
by
the
various
vendors.
Then
we'll
we'll
miss.
There's
like
some
fixable
thing
that
just
we
don't
get
the
feedback
on,
because
we
haven't
kind
of
asked
for
it
in
the
best
way
and
then
we'll
like
be
like
oh
crap.
This
is
gonna,
be
a
huge
pain
in
the
ass
to
fix
later
on.
C
A
B
Mean
I
can't
speak
for
the
rest
of
the
team,
but
I
think
from
my
point
of
view,
yeah
I
think
we'd
be
more
comfortable
with
they've
been
to
and
yeah
I
just
think
it's
just
the
affordance
is
that
that
provides
at
the
at
the
sort
of
sacrifice
of
purity.
Of
you
know:
single
SDK,
yeah.
D
I
I
would
be
shocked
if
there's
I
would
be
shocked
if
anyone's
like
argued
strongly,
apart
from,
like
maybe
me
and
Justin,
for,
like
just
the
the
kind
of
universal
thing,
because
it's
just
just
from
the
just
the
pragmatic
part
of
like
you've
already
got
almost
I.
Think
every
vendor
already
has
like
the
two
different.
The
two
Paradigm
thing
going
on
and
so
like
implementing
like
the
universal
Paradigm,
is
just
going
to
be
way
more
way,
more
work
and
way
more
risk
of
like
semantic
differences.
D
C
Yeah
I
think
I.
Think
cloud
views
is
a
little
bit
of
unusual,
but
they're
they're
also
a
a
good
example
of
of
how
you
can
basically
fit
the
multi-context
Paradigm
into
the
single
into
a
single
context.
Paradigm
easily,
like
I
I've,
did
I've
done
that
in
a
little
POC
like
it's
and
and
there
the
differences
that
I
mean
I,
I,
think
in
usage,
even
being
a
a
person,
who's
worked
at
cloudbase
and
also
use
the
cloudbase
SDK.
It's
used
the
same
way
as
all
the
other
sdks.
C
Really
it's
like
a
you
know
representing
a
single
context,
but
the
reason
that
it,
it
kind
of
accepts
context
in
its
evaluation
even
on
the
client
it
doesn't
do.
Bulk
evaluation
is
because
the
all
the
evaluation
logic
is
shipped
to
the
client
in
entirety,
right
which
we've
talked
about
before,
but
that
but
they're
very
unusual
in
that
sense
is
I.
I,
don't
I
mean
I.
I
could
easily
see
that
other
vendors
have
implemented
that
way,
but
I've
never
seen
one
besides
Club
these
Implement
things.
D
I
think
I've
heard
of
a
few
that
have
done
it
that
way.
I
can't
remember
which
ones
I
feel
like
the
split
used
to
have
like
something
kind
of
similar
to
that
I
think
I'm
sure
there's
something
to
do
it,
but
but
like
yeah
well
anyway,
yeah.
B
I
think
a
lot.
A
lot
of
the
providers
have
on
the
server
side.
They
have
you
know
yeah,
the
the
server
SDK
can
do
the
whole
rules
engine
itself
internally,
but
none
and
yeah
I
there's
most
of
them
the
client-side
ones.
They
don't
do
that.
We
definitely
don't
do
that
because
we
just
wouldn't.
C
Yeah
that
that
is
the
interesting
that
is
the
interesting
corollary
to
doing
everything
on
the
client.
Is
that
encoded
obfuscated
or
not
that
stuff's
all
being
shipped
to
the
client.
D
Hey
can
I.
There
was
one
thing
that
one
last
thing
that
we
maybe
we
won't
get
time
to
talk
about,
but
I
want
to
kind
of
put
out.
D
There
is
I
think
that
as
part
of
the
evaluation
being
done
kind
of
like
as
a
on
the
side
and
and
therefore
like
it's
very
possible
for
me
as
a
consumer
to
ask
for
a
flag
and
for
it
to
be
like
the
evaluation
to
be
going
on,
there's
I
think
it's
worth
us
putting
into
the
spec
a
well-defined
kind
of
set
of
states
for
this
flag
is
a
previously
evaluated,
but
possibly
now
non-authoritative
flag
versus,
like
that's
like
the
default,
like
I.
Think
we
have
to
think
about.
D
What's,
because
this
would
get
this
will
be
I
almost
certain
will
be
different
for
different
vendors
in
terms
of
the
semantics,
but
like
what's
the
behavior,
when
I
had
at
some
point
evaluated
a
set
of
flags
I
know
the
context
has
changed,
but
I
don't
have
the
new
set
of
flags
right,
because
some
people
will
use
a
default.
Some
people
will
use
the
previous
set
of
flags.
So
I
think
that
we
need
to
think
about
like
baking,
like
actually
baking
those
semantics
into
the
spec
and
like
a
defining
like
a
state.
D
D
It
was
you
know,
the
evaluation
context
has
changed
since
then,
or
we've
just
booted,
and
these
are
the
default
set
of
flags
that
that
we
have
from
the
last
time
the
app
was
run
like
I
think
we
we
I,
don't
think,
there's
that
a
huge
amount
of
that
detail
in
the
kind
of
proposed
changes
at
the
moment
and
I
think
we
need
to
do
that
as
part
of
this.
C
C
For
instance,
like
I,
say
this:
this
flag
is
resolved.
It's
not
cached,
because
I
think
cached
there's
an
assumption
that
it's
it's
it's
still
valid,
but
we
could
say
something
like
stale
or
something
in
that
category.
That
says,
you
know
retrieve
from
a
cache,
but
this
cache
may
not
represent
you
know,
authoritative,
to
use
your
yeah.
That's
like.
D
I
mean
I
I
like
authoritative,
because
it
is
more
like
the
kind
of
the
semantics
of
like
kind
of
like
you
know,
resty
type
stuff,
where
it's
like
well
like
a
DNS,
yeah
yeah,
where
it's
like.
This
is
like
valid
and
it
could
still
be
valid.
But
like
we
haven't,
we
don't
know
for
sure,
because
we
didn't
go
all
the
way
back
to
the
to
the
server
recently
yeah
I.
D
I
think,
as
an
application
developer,
there's
it's
going
to
vary
right,
because
because
so
that
so
one
thing
that
so
launch.p
does
this
I
believe
you,
you
have
the
option
as
an
application
developer.
D
If
you
get
back
a
set
of
flags
that
aren't
necessarily
up
to
date,
you
can
either
show
a
loading
spinner
or
you
can
use
that
stale
value
and
evaluate
the
flags
based
on
that
right
and,
and
so
there's
going
to
be,
there's
definitely
going
to
be
people
on
the
application
offer
side
or
the
implementer
side
that
want
to
know
that
context,
so
they
can
decide
to
do
to
do
one
or
the
other
and
I.
D
Think
there's
like
a
third
where
you
can
handle
it,
where
you
go
to
the
default
value,
if
it's
not
authoritative,
so
there
I
think
there's
almost
definitely
particularly
bigger
companies
that
already
have
like
an
existing
thing.
D
I
think
there's
going
to
be
cases
where
people
want
to
use
it
either
for
writing
hooks
if
they're
like
implementers
or
just
for
deciding
like
in
the
context
of
a
specific
screen
like
if
I'm,
not
sure,
just
in
some
contexts,
if
you're
not
sure,
it's
fine
to
just
show
the
default
right
like
if
it's
like
an
A
B
test,
or
something
like
that.
D
In
other
context,
where
it's
like
a
feature
release
of
like
scientist,
half
finished
or
if
it's
like
an
operations
toggle
or
something
like
that,
you're
going
to
want
to
just
say,
like
I,
don't
know
so
I'm,
just
not
going
to
do
anything
until
I
know
for
sure.
C
Configuration
like
you
might
be
able
to
configure
a
provider
in
a
certain
case
to
say
block
until
you've
done
your
initial
fetch
or
not
like
don't
omit
the
on
ready
until
like
you
might
be
able
to
pass
into
the
Constructor
for
the
provider
like
some
kind
of
configuration
specifying
that,
but
even
regardless,
I
still
think
it's
valuable
and,
and
one
of
the
other
reasons
why
it's
valuable,
even
besides
your
point
is,
is
in
debugging,
so
you
know
we
have
the
reasons,
for
example,
going
to
our
open,
Telemetry
integration
and
stuff,
like
that.
C
F
I
mean
don't
get
me
wrong,
I
understand
why
you
want
to
do
it,
but
I
just
want
to
avoid
that
you
have
to
in
this,
if
case,
for
every
flag,
that
you're
evaluating
I
think
we
should
have
to
say
Okay
how
we
can.
How
can
I
really
affect
your
behavior
I
mean
yeah
the
idea
that
I
set
the
context
and
even
want
to
have
okay
call
me
back
when
all
the
information
is
loaded
with
the
spinner
yep,
but
I
want
to
avoid
it
for
every
flag
that
somebody
says
everything
is
this
stale?
F
Okay,
if
it's
there
I'll
then
get
me
back
to
another
to
another,
but
I
think
we
should
be
very
clear
how
this
information
should
be
used.
So
you
don't
get
people
into
like
writing
a
lot
of
codes
that
has
nothing
to
do
with
their
replications
for
ending
situations
that
shouldn't
be
handled
by
default.
That's
I.
A
D
I,
don't
know
whose
decision
it
was,
but
the
idea
of
having
like
the
the
easy
mode
call
where
you
just
asked
for
the
actual
flag
and
then
the
Hard
Mode
called
where
it
gives
you
all.
The
details,
I
think
was
a
really
really
really
good
like
ergonomic
decision,
because
it
means,
unless
you
really
care
about
that
stuff.
You
just
like
say:
hey,
give
me
the
flag
value
and
it
gives
you
the
result.
You
don't
have
to
care
about
all
of
this
authoritative
nonsense.
You
can
just
ask
for
the
result
and
then
use
it.
C
One
thing
I
wanted
to
go
back
and
correct
the
record
on,
because
maybe
Justin
had
had
more
more
of
a
valid
point
that
he
that
I
gave
him
credit
for
was
even
in
the
case
of
for
example.net
somebody.
Somebody
corrected
me
that
there
is
that
there
is
like
a
Frameworks
exam
room,
Etc
that
do
have
client-side.
C
They
do
have
client-side
applications
for
for
for
languages
like
that,
so
it
may
be
that
we
do
end
up
writing
more
sdks
than
you
know,
then
significantly
more
sdks
than
we
otherwise
would.
If
we
go
with
the
the
multiple
paradigms,
not
sure
yeah,
the
the
demand
for
those
particular
languages
is
probably
also
different,
like
certainly
we're
going
to
write
a
web,
slash,
JavaScript,
client-side
SDK.
D
I've
got
a
I've
got
a
job,
but
thanks
thanks
Todd
for
all
the
hard
work
on
this.
It's
really
good.
C
Oh
yeah,
we're
already
a
time
I
didn't
realize
that.
Thank
you,
everybody
for
for
for
coming
contributing,
I'll,
I'll
post
the
recording
as
usual
and
I'm
gonna.
Try
and
collect,
collect
our
thoughts
and
notes
and
update
issues
ETC.
So
thanks
everyone's
time.
Thanks.