►
Description
- Awareness about to ship behind a feature flag
- A little intro into Ruby + Rust bindings
A
Friends
and
welcome
to
another
update
of
real-time
editing
of
issue
descriptions
this
week.
I
want
to
give
you
a
short
update
on
how
the
awareness
widget
is
doing.
It
has
officially
moved
into
the
review
process.
A
So,
as
you
can
see
on
my
screen,
all
the
good
chess
here
on
the
top
is
going
to
be
added
to
the
issue
sidebar,
so
the
empty
state
currently
is
shared
to
collaborate
link.
If
you
click
on
it,
it
gets
automatically
automatically
added
to
your
to
your
clipboard
on
this,
mr,
you
can
see
all
the
potential
states
like
single
collaborator
when
you
hover
over
the
collaborator.
What
the
current
state
is,
two
collaborators,
etc
etc
so
includes
all
the
active
states
includes
all
you
know.
A
If
there's
any
overflow
of
users,
like
more
than
four
users,
are
kind
of
like
put
into
the
the
more
collaborate
this
you
get.
A
pop
over
inactive
states
are
also
there
yeah,
hopefully,
the
last
week
before
the
ships
was
took,
took
quite
a
while
to
get
there
yeah.
A
Another
thing
I
want
to
show
you
is
like
how
the
ruby
rust
binding
is
actually
is
actually
working,
as
some
of
you
know
we're
relying
relying
on
a
library
that
is
written
in
rust,
called
y
c
or
crdt
or
wires,
and
this
is
a
crd.
A
This
is
a
crtt
implementation
that
is
quite
popular
because
it's
based
off
of
one
of
the
most
popular
javascript
library
libraries
used
in
that
space
named
ygs
and
what
we
are
doing
in
order
to
bring
crdts
to
gitlab,
which
is
a
ruby
application,
is
we
need
to
provide
a
ruby
version
or
a
ruby
binding
for
those
crttts,
and
so
this
is
why
we
ended
up
like
building
this
by
rubygem,
and
this
is
why
rubychamp
is
nothing
else
than
a
finn
wrapper
around
the
rust
library,
but
the
actual
implementation
of
them
jam
is
quite
interesting,
because
there's
many
there's
a
couple
of
ways
to
do
that
and
ruby
is
somewhat
known
to
deal
with
natick's
at
native
extensions,
a
lot
like
even
when
you
install
or
when
you
create
a
new
rails
application
from
scratch.
A
You
have
to
install
a
couple
of
native
extensions,
but
most
of
them
are
written
in
c
and
not
in
rust.
Rust
is
a
relatively
I
mean
it's
not
a
completely
new
language,
but
it's
a
relatively
new
language
used
for
ruby
native
extensions
and
those
native
extensions
can
be
written
in
several
ways
like
you
could
expose
rust
functions
directly.
We
wired
a
c
for
a
function.
Interface
like
this
is
supported,
but
it's
not
super
comfortable
and
I
want
to
show
like
how
we
are
doing
it
and
what
we
are
using
for
it.
A
So
this
is
the
why
ruby
repository
and
the
library
repository
is
not
terribly
complex.
It's
basically
like
two
source
folder.
We
have
the
lib
folder,
which
is
you
know
your
regular
rubygem
structure.
It's
not
super
exciting.
You
know
it's
just
a
few
ruby
files
and
we
have
this
nice
little
extension
folder
here
and
it
contains
all
the
native
extensions
that
are
built
in
rust.
We
have
a
single
one.
A
It's
the
by
ruby
native
extension
and
this
particular
structure
is
set
up
by
a
library
called
magnus
and
magnus
is
a
high
level
framework
or
library
that
allows
us
to
write
ruby
to
rust
bindings
in
a
relatively
convenient
way.
There
is
already
a
by
ruby
where
railroad
gem
published,
which
isn't
using
magnus
it's
actually
relying
on
rooty,
which
is
another
great
tool
to
write
this
kind
of
gems,
but
magnus
has
a
few
features
that
I
really
like,
and
I
want
to
show
you
what
what
exactly
I
mean
by
that.
A
So,
let's
just
take
a
look
at
the
array
class
here,
which
is
you
know,
you're
kind
of
like
familiar
with
an
area
in
ruby.
I
assume-
and
you
can
you
know,
get
a
specific
item
at
a
specific
index.
You
can
insert
an
item
at
a
specific
index.
You
can
iterate
over
an
array
and
all
those
operations
somehow
need
also
somehow
need
to
be
supported
by
the
crdt
version
of
an
area
as
well,
and
we
want
to
make
it
as
easy
as
possible
for
ruby
developers
to
interact
with
crdt.
A
A
So
what
we
see
here
is
that
the
the
insert
like
when
we're
inserting
at
a
specific
index,
we
actually
call
a
y
array
insert
method
or
function,
but
this
method
doesn't
really
exist
here
because
it
exists
in
rus
and
it's
just
a
binding
between
the
ruby
and
rust
library.
And
if
we
go
to
the
ras
code
here,
we
can
see
this
y
array
insert
method
and
how
it
is
structured-
and
this
is
kind
of
interesting
because
we
can
see
the
index
here
is
an
unsigned
integer,
and
this
is
not
really.
A
But
there's
also
this
magic
value
here,
which
is
a
ruby
value
which
can
be
literally
any
valid
ruby
valley,
because
you
can't,
you
know
technically
insert
anything
into
an
array
and
yeah.
This
was
a
short
journey
or
a
short
intro
into
like
ruby
and
rust
bindings
are
done.
I
hope
you've
somewhat,
like
the
additional
technical
detail
and
yeah
see
you
soon.