►
From YouTube: Tech Talk: Intro to Extensions
Description
Julien Eluard gives an overview and introduction to extensions in Status. This addition to how developers can create on Status will be a powerful way to build in a web3 environment.
A
Thank
you,
everybody
for
joining
this
Tech
Talk.
My
name
is
Julia
and
I'm,
a
closer
developer,
part
of
the
Dobson
dev
team,
and
the
goal
of
this
talk
is
to
present
extensions
where
a
level
concept
in
and
just
how
they
defeat
the
statues
and
the
blockburger
picture
of
depth
in
general
all
right.
So
what
are
extensions
anyway,
so
extensions
are
a
way
for
third
parties
and
third-party
developers
to
extend
statues
and
just
provide
directly
within
statute
the
application,
their
own
features
and
and
flag
with
their
own
debt
level
application.
A
So
they
do
this
by
just
leveraging
statues
features
and
with
a
natural
feeling,
so
that
there
is
no
way
technically
to
distinguish
between
a
status
feature
and
an
extension
and
that's
kind
of
the
goal.
So
and
because
we
have
this
power,
we
also
needed
to
take
extra
care
specifically
around
privacy
and
security,
because
essentially
you
allow
anyone
to
to
modify
statues.
So
we
need
to
have
some
very
strict
rules
here
and
make
sure
that
no
one
will
we'll
be
able
to
leverage
that
to
to
just
know,
store
information
on
one
year
in
general.
A
One
of
the
main
concept
we
are
here
to
is,
but
we
want
to
to
have
extensions
decentralized
first
right,
so
because
that
the
concept
of
DEP
in
general
is
really
about
being
this
centralized,
but
then
the
reality
that
most
devs
are
not
really
the
centralized
and
they
usually
rely
on
all
the
web
features.
So
we
want
you
to
move
away
from
this
and
and
push
all
the
decentralization
features
sings
two
stitches
and
the
final
point
is
extension-
should
be
really
easy
to
to
build.
A
A
A
So
one
thing
we
want
to
allow
myself
a
TI
developers
to
do
is
to
create
their
own
chat
commands
and
you
can
sing
like
in
group,
chats
sing.
There
is
a
great
potential
for
chat
commands,
because
then
you
have
access
to
the
order
contact
you
have
in
this
chat
and
when
example
e
is
a
split,
the
bill
kind
of
application.
So
here
you
could
directly
split
the
bill
bit
among
like
the
participant
of
your
chat
and
and
because
you
can
leverage
a
theorem,
you
can
directly
pay
and
and
do
more
advanced
stuff
here.
A
Another
potential
example
is
streaming
video,
so
in
chat
application
you
released
in
streaming.
Video
is
kind
of
something
important.
We
don't
have
it
right
now
and,
having
extension
with
the
law
like
Auto
III
reom
project,
to
provide
this
feature
at,
for
instance,
life
pier,
is
providing
that
kind
of
feature.
So
if
we
can
add
them
directly,
implement
live
streaming
for
us.
That
would
be
actually
quite
huge
or
other
examples
like,
for
instance,
better
decks,
integration
or
decks
are
kind
of
big
use.
A
Cases
in
a
theorem
so
would
be
nice
to
to
allow
them
to
just
plug
in
chat,
for
instance,
or
maybe
invalid,
and
and
provides
for
more
advanced
user
interface.
In
the
same
way,
we
also
have
a
so
nice
ESC,
20
and
721
integration
in
violets
for
ESC
721.
So
and
if
cheese,
it's
it's
kind
of
a
dark,
so
we
have
statues.
A
We
have
to
provide
the
implementation
Terra
token,
but
if
we
open
this
to
two
subpart
C
developers,
then
it
could
be
any
NFC
provider
that
would
directly
implement
for
us
this
this
particular
feature
and
last
year.
Lastly,
another
interesting
ID
is
allowing
to
to
have
ephemeral
application
running
inside
status.
So,
for
instance,
let's
say
you
go
to
a
restaurant
and
and
then
you
you
want
to
have
access
to
the
menu
or
just
order,
something
you
could
scan
a
QR
code
with
statues
and
then
directly
have
access
to
to
do
this.
A
This
way
to
interact
with
the
restaurant
and
then
because,
probably
you
don't
want
to
accumulate
all
those
extensions
pair
restaurant
because
it
would
just
be
a
big
mess,
so
it's
just
something
that
you
would
throw
away.
It's
like
you,
you
scan
the
QR
code,
you
use
the
application
and
then
you
move
on
so
it's
kind
of
now
put
on
show
your
sketti
the
blessing
that
there
can
be
a
lot
more.
A
A
A
Then,
on
top
of
that,
we
implemented
or
higher
level
features
like
wallets
and
chats.
So
those
are
native
implementations
and
buy-in
achieve
I
mean
that
they
rely
on
mobile,
specific
API
and
they
provide
like
very
nice
interaction
and
user
experience
and
and
smoothness,
and
then
on
top
of
that,
dabs
are
webbed
apps
that
the
dots
you
currently
know
like
cryptokey
till
the
they
will
run
on
top
of
all
browser
implementation.
A
So
now,
if
you
take
a
look
to
the
the
diagram
below,
so
that's
extensions
and
it's
fairly
similar,
but
the
difference
is
that
now
the
the
extension
will
run
directly
within
all
Native
layers,
so
which
means
first,
that
you
will
get
much
better
performance
and
and
platform
integration.
So
you
will
get
much
more
interesting,
visual
results,
but
also
it
means
you
can
interact
much
more
cruzi
more
closely
with
all
the
features
that
statues
provides
and/or
the
api
we
are
like,
for
instance,
you
can
directly
reuse.
A
Well
that
features
or
maybe
more
interesting,
like
chat
features,
you
could
leverage
your
contacts
and
and
just
send
the
messages,
and
that
kind
of
things
directly
from
within
your
extension,
so
which
I
think
is
very
interesting
for
that
developers,
because
then
they
can
leverage
well
or
contacts.
For
instance,
I,
don't
have
to
rebuild
set
of
contacts
and-
and
they
can
directly
send
chats
also-
which
is
something
that
is
kind
of
unique
to
state
use
peer
to
peer
chat,
so
yeah.
A
So
to
design
extensions
and
all
the
architecture
behind
those
those
concepts
we
follow.
Some
some
principals
and
probably
the
most
important
ones,
are
related
to
the
security
and
privacy,
as
I
said
before,
because
extension
will
be
directly
running
within
statues,
they
potentially
could
access
anything.
But
obviously
we
don't
want
that.
So
we
still
want
to
make
sure
that
any
user
on
the
written
full
control
on
the
kind
of
information
they
will
share
and
but
they
cannot
be
easily
scandal,
but
they
will
not
lose
any
found
all
that
kind
of
things.
A
So
that's
kind
of
like
the
main
principle
we
have
when
designing
extensions.
So
one
when
you
divide
the
principle
is
that
extensions
are
completely
data
based.
So
it's
not
a
full
programming
language.
It's
just
some
kind
of
configuration
that
you
will
load
instead
inside
stages.
So
it's
important
because
then
it's
much
more
easy
for
statues
to
analyze
and
understand
what
this
extension
is
doing
and
then
status
is
able
to
inform
and
user
of
what
potentially,
this
extension
will
do.
So
that's
how
you
can
get
the
end
user
for
control.
A
Another
important
principle
is:
we
try
to
make
breathing
and
extension
very
simple
and
very
easy
to
manage
the
lifecycle
of
your
extension,
like
publishing,
needs
and
and
providing
new
versions,
so
that
kind
of
things
so
very
few
concepts
agnostic
to
the
host
platform,
the
way
which
I
will
detail
a
bit
later
and
no
not
will
is
just
you
have
this
configuration
that
a
days
that
we
represent
your
extension,
but
then
that
that's
its.
This
is
the
only
senior
there
is
no
brief.
A
There
is
no
nurturing
is
just
one
file
that
you
share
and
some
decentralized
storage,
so
I
will
just
quickly
introduce
some
concepts
behind
extension
and
so
an
extension
implements
different
hooks
and
the
hooks
are
defined
by
oast.
So
in
our
case
the
status
is
lost,
so
statues
will
specify
what
can
be
extended
and
then
an
extensions
can
provide
implementation
of
those
different
hooks.
A
Then,
when
you
want
to
concretely
implement
your
extension,
you
will
manipulate
concepts
of
views,
queries
and
events.
So
with
those
four
concepts,
hooks
views,
queries
and
events,
that's
pretty
much
all
you
have
to
know
to
create
an
extension.
Then
extension
allows
to
defer
on
this.
On
dry
storage,
like
ipfs
or
swamp,
and
the
leverage
a
theorem
is
very
tied
to
earlier
theorem
concepts
like
with
all
the
contract
stuff
and
then
as
a
statue.
So
how
do
you
manipulate
extensions?
And
what
can
you
do
with
extensions?
A
Some
information
detailing
what
is
involved
with
this
extension
and
you
have
the
you
still
have
the
control
you
can
decide
to
install
it
or
not,
and
once
it's
installed
you
can
deactivate
it
for
not
so
that
there
is
some
concept
of
lifecycle
of
an
extension,
so
extensions
are
built
on
top
of
from
work
called
the
Pluto
which
is
separate
from
statues,
mainly
just
to
simplify
and
because
statues
is
already
quite
a
complex
code
base,
but
also
the
interesting
concept
here.
That's
brittle,
which
provide
the
implementation
of
all
the
concepts
is
host
agnostic.
A
So
status'
is
the
mobile
OS
for
Pluto,
but
you
can
imagine
like
OSA
host
like,
for
instance,
web
web
based
host
and
actually
that
we
are
using
the
web
based
host
to
perform
more
tests
and
and
to
simplify
the
development
of
Pluto.
So
yeah,
that's
kind
of
what
I
wanted
to
detail
here.
So
you
will
provide
all
the
implementation
of
the
basic
building
blocks
and
logic
behind
the
concepts
it
will
also
like
abstracts
or
the
interim
interaction.
A
So
that's
the
job
of
Pluto
and
then
each
host
and
the
first
one
and
the
most
important
one
is
statues
hosts.
They
will
implement
the
native
of
view
because
Pluto
is
really
just
an
abstract
grammar
for
for
your
for
your
dad,
but
then
because
we
want
to
have
this
native
integration
and
natural
feeling.
This
has
to
be
implemented
by
by
the
O's
like,
for
instance,
in
the
case
of
statues.
A
This
will
be
implemented
using
a
react
native
yet
provide
the
earth
like
direct
like
integration
with
the
mobile
API
and
then
the
second
thing
that
the
host
will
define
is
all
the
hooks.
So
how
can
statues
be
extended
like,
for
instance,
one
of
the
main
extension
well,
one
of
the
main
hook,
his
chat
commands,
but
then
you
need
pair
lost.
A
So
I
will
go
through
those
those
concepts
in
just
a
bit
more
details,
but
not
very
technical,
so
should
be
fine,
so
yeah,
that's
kind
of
what
I
was
saying
but
host.
Who
can
sorry
is
what
I
lose
like
develop
last.
We
understand
what
she's
exposed
by
status'
so
yeah
as
I
was
saying,
chat,
commands,
but
also
specific
pen
to
containers
like
if
you
want
to
to
customize
how
cryptic
it
is
is
displayed
inside
statues.
This
will
be
a
different
type
of
hook
and
those
hooks
they
are
implemented
by
extension.
A
So
once
you
will
load
an
extension,
then
you
will
see
all
the
different
hooks
that
are
provided
and
implemented
by
DC
these
extensions
and
as
in-hand
user
on
this
is
kind
of
what
you
care
about
which
hooks
will
be
implemented,
and
those
hooks
have
some
specific
semantics.
So
each
hook
that
you
will
define
note
that
the
kind
of
information
that
is
needed
to
implement
it
like,
for
instance,
a
chat
command.
You
must
provide
a
scoop
like
will
it
be
able
variable
in
just
one
one
chat
or
in
privileged
chat?
A
So
this
is
an
information
that
has
to
be
provided
by
the
extension,
and
this
is
validated
during
the
installation.
So
once
you
will
load
an
extension
inside
statues
that
just
will
verify
that
the
all
the
implementation
match,
the
definition
and
so
that
there
is
no
mismatch
and
all
the
contracts
are
fulfilled.
A
Views
are
the
the
UI
elements
or
how
you
manipulate
information
technically
doesn't
have
to
be
completely
UI
ability.
It
could
be
like
a
command
line
stuff,
for
instance,
those
it's
really
just
how
you
want
to
manipulate
and
surface
the
the
data
inside
statues,
so
it's
purely
declarative
based,
so
which
means
you
will
once
just
define
the
shape
of
your
information
and
how
its
exposed,
but
but
then
it's
very
static
and
easy
to
do,
which
is
like
a
big
shift
from
traditional
web
development.
A
So
it's
very
similar
to
what's
reacted
us,
and
so
then,
once
you
have
the
shape
of
what
you
want
to
display,
you
need
to
define
how
this
information
is
linked
and
well
is
the
information
coming
from.
So,
in
extension,
everything
is
stored
in
a
single
place,
called
the
local
state
and
and
I
will
detail
just
in
next
slide
how
it
works.
A
So
you
do
this
through
the
concept
of
query
and
query
is
a
way
to
just
detail
what
kind
of
information
I
want
to
retrieve
and
then
I
will
assign
this
information
and
I
will
just
define
it
inside
my
my
view,
so
it's
better
than
the
concept
of
universal
data
flow
so
which
means
it's
again
very
declarative
and
Static
you,
you
will
define
statically
what
you
want
and
then
every
time
your
information
is
modified
inside
status,
the
the
content
and
the
view
will
be
updated
automatically.
You
don't
have
to
to
do
anything
specific
editor
for
that.
A
So
let's
say,
for
instance,
know
you.
You
are
interested
in
like
a
SNC
exchanges.
You
could
define
okay
I
want
to
hook
my
view
to
to
some
some
s
and
here
details
and-
and
then
you
just
specify
this
and
every
time
some
essentially
exchanges.
We
will
go
through
your
status
node.
That
will
be
reflected
in
your
extension,
so
it
makes
like
you
a
very
predictable
and
very
easy
to
to
build.
A
And
finally,
then,
how
you
can
have
user
interact
and
make
modifications
with
your
extension,
so
she's
done
through
the
concept
of
events
and
events
are
the
only
way
to
to
modify
the
local
states.
So
there
are
two
ways
to
do
that:
either
it
will
be
through
a
user
interaction
like,
for
instance,
clicking
on
a
button.
Then
you
you
can
trigger
an
event.
A
A
Yeah,
so
here
you
can
see
so
it's
working
progress.
So
it's
really
it's
just
my
design.
It
has
to
be
designed,
so
it
was
no
official
design
yet
so,
in
the
profile
night,
we
have
an
extra
element:
extensions
which
is
unavailable
because
I'm
in
development
mode
and
if
I
go
inside
here
so
I
can
see
that
whoops
was
a
bit
quick,
but
there
are.
A
There
are
no
extension
by
default
and
then
so
you
can
add
extension
from
within
this
by
providing
like
the
URL
or
you
can
also
scan
a
QR
code,
so
which
is
what
I
will
do
next
so
I'm
leaving
status
and
I'm
launching
my
camera
app
and
scanning
just
a
QR
code.
So
it's
just
like
the
stock
camera
application.
You
have
on
your
phone
and
then
I
can
open
it
in
status,
which
is
like
the
because
it's
actually
inside
this
QR
code.
A
There
is
a
universal
link
and
this
universal
link
points
to
an
extension,
so
I'm
scanning
it
okay
and
then
here
directly,
I
can
see
that
I
have
like
some
new
new
screen.
That
show
me
some
details
about
this
extension
so
essentially
the
which
means
extension.
This
is
so
for
this
example:
it's
just
loading
a
github,
a
file
I
have
access
to
some
meta
information,
like
name
description
and
finally,
so
it's
really
bad.
A
You
can
see
there
are
no
permission
required
to
use
this
book,
so
this
is
an
information
for
the
end
user
just
too
so
that
they
can
understand.
What's
going
on
what
is
the
threat
level
associated
to
this
extension,
and
when
we
loaded
this
extension,
we
didn't
identify
in
any
arrow
and
then
here
so
you
can
see
that
we
can
install
it
them.
A
A
Okay
and
now
we
go
back
to
the
chat
and
we
can
see
that
there
is
a
new
command.
So
it's
really
it's
a
real
demo.
It's
not
like
no
Photoshop,
though,
and
you
can
execute
this
come
on
and
get
well.
It's
not
very
useful
what
this
command
does,
but
at
least
it's
it's
showing
something
oops!
Well,
okay,
so
that's
kind
of
the
most
technical
slide,
but
it's
just
to
show
what
actually
he
is
an
extension.
A
So
this
one
he
is
exactly
the
one
with
that
we
should
do
so
in
in
the
small
demo
and
you
can
see
I
opened
a
bunch
of
meta
information
and
then
here
is
the
the
implementation
of
this
hook
so
dynamic
command.
So
you
can
see
that
it's
available
in
public
chat
and
personal
chat,
that
it
has
one
parameter
whose
name
is
name
and
which
type
is
text,
and
once
it's
sent
it
will
be
previewed
using
this
view.
A
So
this
is
some
kind
of
syntax
to
to
reference
this
view,
which
is
preview
and
here
so
that
that's,
like
the
view,
syntax.
No,
this
view
which
is
kind
of
abstract
way
to
to
detail
information
and
a
text
element,
and
this
text
element
contains,
as
labelled
from
which
is
some
information
extracted
from
the
command
itself.
A
Okay,
so
what's
next
next
iteration
and
we
are
targeting
as
a
bearing
for
this,
so
we
want
to
allow
third-party
developers
to
provide
their
own
logic,
because
what
I
just
showed
so
far
is
really
I.
Think
it's
very
powerful,
but
still
it
will
be
limited
somehow,
because
there's
no
programming
language
involved.
So
if
you
want
to
do
some
more
advanced
stuff,
then
you
need
to
provide
your
own
code,
probably
using
JavaScript,
because
that's
kind
of
the
most
most
common
language
used
those
days.
A
So
that's
what
we
want
to
implement,
so
it
will
have
to
be
run
inside
the
sandbox,
so
a
specific
JavaScript
runtime
that
will
only
have
access
to
specific
information
and
specific
subsets
of
the
local
states
and
that
kind
of
things
I'd,
probably
message-passing
based.
So
it's
still
working
for
us,
we're
not
quite
clear
how
to
implement
that,
but
but
that
would
be
an
option
and
similarly
well
right
now.
Views
are
also
similar.
A
Almost
HTML,
you
have
access
to
text
inputs,
lists
that
kind
of
things,
but
then,
if
you
want
to
go
crazy
and
implement
like
a
map
or
very
advanced
stuff,
like
all
games,
come
that's
based
games.
So
to
do
this
we
would
use,
makes
a
make
a
lot
of
sense,
I
think
and
then
there
is
no
real
limits
to
what
you
can
do
in
an
extension,
but
that's
the
goal
for
it:
Berlin
next
iteration,
so
right
now
extension
only
ephemeral.
So
you
scan
your
QR
code.
You
get
the
extension!
A
Well,
once
you
restart
statues,
then
it's
gone
and
the
same
way.
So
all
data
associated
with
this
particular
extension
are
gone.
So
we
want
to
provide
persistence,
persistence
and
so
the
statues
results.
If
you
want
to
because
I
think
maybe
most
of
the
extension
probably
don't
want
to
to
be
persistent
actually
and
then
the
last
one
for
now
would
be
for
such
target,
see
the
status
icon,
and
so
it's
it
would
introduce
the
concept
of
dependency.
A
So
having
extensions
depends
on
other
extensions
and
we
use
code
written
by
other
people
and
kind
of
related
concept
is
versioning.
So
once
you
publish
your
extension,
then
you
want
to
push
a
new
version.
So
how
can
you
inform
end
user
so
that
so
it
will
probably
be
based
ENS
and
just
updating
your
ENS
to
point
to
a
different
version,
or
something
like
that.
A
So
dependency
are
quite
an
important
and
interesting
because
well
we
have
a
number
of
very
interesting
project
in
a
theorem
like
things
maybe
like
foam
fo
am
not
sure
if
I'm
pronouncing
this
correctly
we're
so
foam
is,
is
a
providing
some
kind
of
decentralized,
coordinate
system
and
I.
Think
this
kind
of
project
are
really
what
will
push
extensions
in
general.
A
If
you
can
just
reuse
that
directly
and
that
they
either
they
provide
extension
or
we
can
implement
this
for
self
and
then
provide
this
as
a
block
that
anyone
can
reuse
we
are
seeing,
is
quite
powerful,
ok,
so
that's
kind
of
very
short
term
goals
now
for
status.
A
cotton
is
making
maybe
two
months
well,
but
then
I
think
there
are
number
of
very
interesting
ideas.
We
can
push
further
once
we
have
this
so
for
ya.
A
The
first
one
is
personally
I,
don't
like
existing
Deb's
web
Deb's
I
think
they
are
really
bad
and
that's
probably
the
reason
why
no
one
use
them.
So
the
extensions
are
kind
of
my
way
to
you
know,
take
away
the
apps
in
the
web
and
even
that
with
the
name
is
terrible.
So
please
find
an
abbot
on
him
and
in
the
future,
I
think
would
be
really
nice
to
have
statues
itself,
because
that
is
a
depth.
A
So
extensions
out
up
everything
is
Deb
know,
so
we
could
have
just
statues
being
a
collection
of
extensions
which
almost
remove
the
dependency
on
Appstore,
because
then
you
would
only
need
that
very
thin
layer
of
statutes
that
provide
the
extensions
report
and
a
theorem
access
and
then
all
the
rest
like.
Well,
it's
the
chat
and
so
on.
A
So
it's
similar
to
a
concept
that
Andre
was
pushing
a
couple
of
nonces
ago
statues
Fidel,
but
it
would
be
like
more
advanced
because
then
now
we
have
also
event
and
queries.
So
so
you
could
create
extensions
with
real
data
like
you,
you
could
like
drag
and
drop
elements,
views
queries
so
on,
and
then
you
directly
see
the
world
thing
works
and
with
real
information
coming
from
the
blockchain
and
so
on.
So
it's
kind
of
here
interacting
developments
in
kind
of
the
old
dream
of
IG.
A
So
we
could
include
this
in
statutes.
Desktop
actually
I
think
because
it
would
be
a
little
bit
hard
inside
the
mobile
because
of
the
of
the
form
factor,
but
on
a
desktop
I
think
it
will
make
sense
to
it.
Well,
this
and
then
more
programmatic,
pragmatically,
well
I
just
need
more
suggestion
of
what
kind
of
things
we
want
to
extend
inside
status.
So
what
kind
of
hooks
we
want
to
make
available
through
to
third-party
developers?
A
So
we
already
have
a
couple
but
I
think
that
well
we
wants
to
have
more,
but
then
it's
also
important
to
always
consider
all
the
privacy
and
security
related
to
this,
because
you
don't
want
to
expose
too
much
and
everyone's
ready.
Some
hooks
might
be
dangerous
just
inherently.
So
that's
something
to
consider.
A
Okay,
so
with
that
I'd
like
to
append
to
the
question
and
feedback
and
just
to
make
sure
you
have
some
time
to
write,
something
I
would
just
know
benefit
this
time
to
thank
some
people
and
for
the
first
one
will
be
yen,
who
implemented
a
lot
of
the
dynamic
chat,
comments,
reports
and
recently
to
the
thanks
to
him.
We
have
this
nice
demo.
A
A
Yeah
yeah
well,
I
think
the
name
that
is
really
confusing,
actually
because
first
I'm
not
sure
that
this
one's
realized
is
actually
a
feature.
Maybe
it's
more
an
implementation
detail,
so
I
think
it's
confusing
for
for
end-users,
what
is
decentralized
anyway,
and
and
even
that
you
have
to
explain
it
to
the
normal
people.
It's
not
transparent.
The
name
is
not
transparent
at
least
well
now,
and
we
we
want
to
move
away
from
the
web
depth
with
extension,
so
we
need
a
new
name.