►
From YouTube: CRDT Research Meetup // AntidoteDB - Nuno Preguiça
Description
Originally recorded during the Lisbon Hack Week from May 21-25, 2018, this talk provides an overview of AntidoteDB and other CRDT-related projects on-going at NOVA LINCS. AntidoteDB (antidotedb.eu) is an open-source geo-replicated database that provides high availability while ensuring strong semantics for applications. To this end, AntidoteDB features CRDTs for providing data convergence, highly available transactions for providing atomic operations over multiple objects, causal consistency for enforcing the causal relations among updates, and mechanisms for enforcing global invariants without compromising availability.
AntidoteDB is being developed in the context of EU H2020 LightKone project.
A
Today,
I'll
be
talking
about
until
TB,
that
is
an
open-source
database
that
we
are
building.
So
before
starts
just
to
give
you
a
quick
presentation
of
where
we
are
coming.
So
we
are
at
North
University
of
Lisbon,
that
is
in
the
other
side
of
the
river,
so
we
are
more
or
less
year,
so
we
are
located
in
the
other
side
of
the
river.
University
is
a
quite
big
University,
with
several
schools,
medical
school,
Science
and
Technology
law.
A
The
typical
schools
that
you
could
think
about.
In
a
university
with
more
than
28,000
students,
the
Science
and
Technology
school
weighs
about
9,000
students
and
in
our
research
centre
the
computing
system,
Krister
/
centre.
We
are
about
20
faculty
plus
postdocs,
and
we
have
about
20
PhD
students
and
lots
of
master
students,
always
working
with
us.
So
the
research
centre
is
is
divided
in
four
areas:
software
systems,
multimodal
systems,
computer
systems
and
knowledge-based
systems.
A
A
Just
to
give
you
points
that,
if
you
want
to
talk
with
me
after
that,
so
in
the
afternoon,
I
will
be
around
so
so
we
will
know
that
joke
application
is
here
to
stay,
and
then
there
is
a
trade-off
between
consistency
and
availability,
and
if
you
look
at
the
record
storage
that
has
been
that
has
been
created
if
we
see
at
the
first
wave
of
cloud
storage
sink
like
Cassandra
and
react.
Basically,
these
data
storage
were
eventually
consistent.
A
Data
stores,
okay,
where
he
basically
evenly
have
guarantee,
is
that
that
will
converge
in
Cassandra
things
would
converge
by
what
writer
wins
react
improved
on
that
the
the
they
have
see
oddities
with
little
matter
semantics,
but
still
everything
was
eventful
consistence.
So
if
you
look
at
the
second
wave
of
cloud
storage,
things
like
cosmos,
DB
spanner
Google
spanner,
so
it
seems
we
moved
completely
to
the
other
side
of
the
spectrum,
and
everyone
wants
to
have
strong
consistency
and
very,
very,
very,
very
strong
guarantees
on
on
on
on
your
data,
but
providing
these.
A
If
even
on
spanner,
that
can
have
good
support
still
the
latency
is
still
I,
and
if
there
is,
if
there
is
problems,
if
there
is
some
network
partitions,
you
still
may
may
get
blocked.
So
what
isn't
it
ought
to
be,
but
basically
until
OTV
is
kind
of
our
answer
to
this
kind
of
two-way
spectrum
in
what
we
are
trying
to
answer
is:
is
it
possible
to
be
I,
believe
I'll
be
available
and
still
provide
strong
semantics,
and
what
do
we
mean
by
strong
semantics?
So
that's
what
I
I
will
tie
to
to
explain
to
you.
A
A
So
the
first
thing
that
we
want
in
general
in
applications
is
that
we
want
all
replicas
to
converge
and,
of
course,
for
these
we
have
the
problem
of
concurrent
updates.
You
all
know
about
deals.
You
can
is
acute
to
operations
concurrently,
you,
you,
then
F
to
decide
what
happens
and
for
solving
these.
Basically,
we
are
doing
what
everyone
is
doing
is
we
are
using
C,
R
DT,
so
now
nothing
especially
here.
So,
let's,
let's
look
at
things
a
little
bit
more
complex,
so
in
a
bank
in
a
banking
application.
A
If
you
only
have
transfers,
we,
basically
you
want
that
the
balance
will
be
equal
to
the
initial
balance
plus
the
deposits,
the
withdrawals
okay.
So
let's,
let's
look
at
what
happens
so
suppose
we
have
two
accounts
and
I
account
starts
with
five
in
a
B
accounts
are
sweet,
one,
okay
and-
and
we
start
to
see
what
is
the
balance
f
I+
b,
the
balance
fi
plus
B
is
6.
A
A
So
if
we
have
everything
here
in
in
DC-
and
we
can
do
acute
operations
immediately,
I
will
be
with
two
and
B
will
be
wait
for
okay,
because
we
are
transferring
three
from
A
to
B,
so
the
problem
comes
now
because,
typically
in
these
systems,
typically
in
these
systems,
I
will
have
to
execute
two
operations
when
to
update
objects,
a
by
decrementing
three
and
another
two
to
apply
to
object
B
for
incrementing
three.
So
so
what
happens
now
if
this
operation
arrives
here
and
I
applied
a
I
know,
is
to
this.
A
B
is
still
1
and,
and
what
happens
is
is
that
if
now
I
try
to
see
the
balance
between
I
in
the
I,
please
be
I.
Get
three
and
I
shouldn't
get
three
because
I'm
doing
a
transfer
okay,
so
the
balance
should
be
still
when
I
my
some
APIs
be
issue.
They
have
still
six
but
I.
Don't
I
have
only
three
I
have
this
because
I
have
been
executing
the
operation
in
the
middle
of
two
operations,
and
this
is
a
problem
that
happens
in
many
applications.
A
A
Basically,
our
approach
for
these
is
to
to
use
something
that
we
call.
I
live
our
transactions.
Okay,
there.
There
are
other
other
systems
that
do
this,
and
there
are
several
protocols
for
doing
this,
but
our
data
buys
F
what
is
called
a
liveable
transactions,
what
our
value
of
our
transactions.
Basically,
there
are
transactions,
okay,
where,
when
you
read
you
read
from
a
consistent
snapshot
when
you
take
it
as
a
set
of
operations,
all
those
operations
are
visible
atomically
or
they
are
not
visible.
A
For
example,
here,
when
you
see
these
updates
in
this
replica,
these
are
plates,
we
one
will
be
visible
after
the
second
one
is
executed
and
not
before,
and
these
guarantees
us
that
we
see
always
a
consistent
state.
Okay
and
this
can
be
done-
can
be
done
in
a
weekly
consistent
way,
so
we
don't
have
to
coordinate
between
between
between
data
centers,
to
do
this
okay.
A
A
So
getting
back
to
this
example,
so
after
a
third
three
to
a
and
B,
okay
and
I,
said
okay
and
I'll
suppose
that
the
client
C
seen
that
the
transfer
has
been
done
and
decided
to
write
in
some
other
object:
okay
and
I'm
having
here
a
log
but
could
be
something
more
complex,
I'd
the
transfer
has
been
done
and
this
object
is
now
replicated
okay
and
in
these
weekly
available
systems.
Typically
objects
are
synchronized
per
object.
A
They
there
is
no
global
synchronization
each
object,
synchronous
itself,
so
this
logo
object
can
be
synchronized
before
these
ones
are
synchronized.
And
now,
if
a
client
comes
and
reads
the
work
in
what
what
will
we
be
see?
Basically,
seeing
that
the
lock
size,
the
transferees
then?
But
the
values
are
still
the
initial
values?
Okay.
So
how
can
we
solve
this?
Basically,
we
can
solve
this
by
enforcing
causal
consistency
and
again
cosmic
resistance
can
be
enforce
it
without
without
coordination
between
data
centers,
okay,
and
this
gives
also
another
set
of
guarantees
to
the
applications.
Okay.
A
A
Okay
in
this
replica,
it
seems
everything
is
fine,
because
the
value
of
I
is
still
1
right.
So
everything
seems
to
be
ok.
The
problem
comes
when
you
you,
you
synchronize,
when
you
synchronize,
basically
you'll
see
that
the
value
would
be
minus
2.
Okay,
because
when
you
propagate
the
updates,
you
combine
the
two
updates
and
you
end
up
with
minus
2.
A
So
this
seems
this
seems
a
situation
where
okay,
in
these
cases,
you
really
have
to
coordinate
right
until
now,
we
are
giving
more
more
guarantees,
but
you
are
not
coordinating,
but
in
this
case
you
you,
you
need
to
coordinate.
Yes,
we
need
to
coordinate,
but
we
can
move
the
coordination
outside
of
the
execution
path
in
many
cases.
Okay,
how
can
we
do
this?
A
But
basically
we
can
do
this
by
so
suppose.
We
have
five
okay,
and
we
pick
this
five
and
we
split
this
five
between
these
two
replicas
and
we
say
that
this
first
replicas
three
in
this
second
replicas,
okay
and
these
three-
this
replicant-
can
use
these
three
without
coordinating
with
the
other
replicas.
This
one
can
use
these
two
without
coordinating
with
the
other
replicas.
So
if
now
is
acute,
I
know
an
operation,
the
quiet
one
to
get
to
know,
operation
Twittersphere,
that's
fine.
I
have
three
year
that
I
can
use.
A
Okay,
so
I
can
determine
I
can
say:
okay
without
kulhanek,
without
the
replicas.
What
happens
if
the
other?
If,
when
the
other
were
forget,
tries
to
draw
four
okay?
I
came
here:
I
see
that
that
I
only
have
two,
and
in
this
moment
I
have
two
to
coordinate
with
other
replicas.
I
could
be
night,
I
see
that
I
cannot.
There
is
no
more
available
and
I
will
file.
What
what
is?
A
What
is
key
here
is
that
so
this
example,
we
are
very
close
to
the
limit,
but
if
you
think
in
an
example
where
you
start
it,
for
example
1000
okay
and
we
divide
this
500
in
each
one,
you
can
use
script
lots
of
operations
without
having
to
coordinate.
You
only
have
to
coordinate
really
we
and
when
you
are
very
close
to
the
to
the
limits.
Okay.
A
So
we
we
have
published
something
that
we
call
bonnet
counters
here,
DT
that
addresses
this
problem.
Okay,
so
and
if
you
look
at
more
or
less
kept,
the
promise
that
we
get
when
you
use
this
bonded
counter.
Okay,
most
of
the
operations
are
very
quick.
Sometimes
you
have
to
coordinate
and
then
your
time
will
be
high.
Okay,
so,
and
we
can
also
do
other
inference.
I
will
not
go
into
details
in
the
other
events,
but
but
I
can
talk
with
you
guys.
A
After
if
you
want
so
basically,
we
are
building
this
antidote
TB
database,
that
is
open
source
that
is
at
get
up.
It's
a
joke
replicated
not
see
cool
data
wise.
That
is
that
is
this
a
wave
of
transactions
theory.
It
is
for
conversions,
casual
consistency,
bonded
total
for
enforcing
numeric
invariants,
and
we
are
building
an
a
sequel,
a
sequel
interface
that
enforces
sequel
it
invariant
automatically
on
the
database.
A
They
we
have
preliminary
version,
also
at
github
for
those
that
want
to
to
to
try
okay,
so
before
I,
finish,
I
will
just
give
you
a
quick
overview.
Father
reality
related
projects
that
are
that
we
are
running
at
empanada
links,
so
one
of
them
is
something
that
we
are
calling
non-uniform,
CID,
T's
or
non
Infinix
application.
So,
basically,
in
in
this
work,
we
are
trying
to
to
answer
this
questions.
So
when
you
think
about
replication,
it
seems
that
all
replicas
will
have
to
have
the
same
state.
A
If,
even
if
the
internal
presentation
is
different,
the
overall
state
seems
to
be
the
seems
to
be
always
the
same,
but
is
this
necessary?
And
the
answer
is
no
think,
for
example,
of
about
a
leader
world
if
you
are
to
maintain
a
leader
board
and
you
only
to
show
the
10
first
positions,
why?
Why
do
you
need
to
wear
the
all
list
in
all
replicas?
You
don't
okay,
so
this
is
something
that
we
are
building.
We
have
also
versions
of
see
oddities
for
for
these,
these
kind
of
things
at
at
github.
A
There
is
a
piper
that
you
can
can
read
it.
The
second
thing
that
we
are
working
on
is
this
privacy
perversity
preserving
see
oddities.
So
the
answer,
the
question
that
we
are
trying
to
answer
here
is
so
suppose
it
you
do
not
you
do
not
trust
you
want.
You
want
to
to
to
keep
the
data
okay,
private,
even
if
they,
if
you
distort
the
in
the
server's
okay,
can,
can
we
build
shared.
It
is
that
we
can
is
acute
operations.
They
can
merge.
They
can.
A
They
can
is
acute
new
operations,
but
all
data
is
is
is
kept
ciphered
and
basically
we
are
building
these
permissive,
preserving
realities.
We
are
using
to
two
basic
approach
when
using
cryptographic
functions
for
some
C
additives,
we
need
a
mom
or
fiction's
for
others.
We
don't
need
we.
We
can
use
things
that
are
much
much
lighter
and
we
are
using
testing
description,
environment
CSS
in
interest
issues.
They
are
basically
two
two
lines
of
approaches
for
addressing
this,
so
the
next
projected
to
we
are
working
is
so
everything
ER
duties
with
multiple
semantics.
Okay.
A
So
what
is
the
problem?
So,
if
you
all
know
about
shared,
it
is
when
you
ever
set
you
can.
When
you
build
an
application,
you
can
have
an
Edwin
theater
where
he
move
in
set,
but
sometimes
in
some
applications.
I
wanted
this
operation
to
be
advanced
in
this
operation
to
be
removing,
and
there
is
no
way
of
doing
this,
and
so
we
are
kind
of
addressing
this.
We
have,
we
have
design
it
see.
Additives
for
sets
that
have
both
both
Edwin's
and
remove
means.
A
Okay,
and
we
are
trying
to
the
design,
see
oddities
that
are
generic,
so
that
the
programmer
can
specify
what
is
the
policy
with
its
operations?
Okay,
when
is
submit
suppression
in
size,
I
want
my
operation
to
be
advanced,
and
this
one
is
remove
ins,
so
they
it's
a
bit
more
complex
step.
Then
it's
a
it's
a
bit
trickier,
but
but
this
is
the
key
idea.
A
So
next
so-
and
these
these
in
part,
is
something
that
we
have
not
done,
but
as
you
you
guys,
it's
it
on
these
I've
I've
added
a
slide
on
this.
That
is
the
problem
of
access
control,
and
we
consistency.
This
is
this
party
has
been
work,
is
work
that
has
been
done
by
a
net
BN
user
and
Matthias
Weber,
and
basically,
they
have
been
trying
to
address
the
problem
of
every
access
control
when
you
have
event
of
consistency
systems.
So
what
is
the
problem?
So
the
problem
is
that
there
are
basically
there
are
two
problems.
A
The
first
problem
is
that
you
can
modify
the
access
control
rules
concurrently,
so
you
have
to
merge
those
access,
control
rules
so
for
this
we
they
have.
This
I
need
acidity,
that
maintains
access
control
rules
and
merges
the
access
control
rules.
The
second
problem
is,
then,
the
interaction
between
the
access
control
rules
and
depressions
that
are
execute
in
the
in
the
objects,
because
you
might
be
securing
an
operation
to
revoke
the
access
to
an
object
and
concurrently,
someone
is
accessing
that
object,
so
basically
they
they
have
this.
A
They
have
designed
it
a
protocol
to
address
this.
This
one
was
implemented
on
antidote,
so
they
have
the
transactions
and
all
those
things
that
would
they
up
a
lot.
Okay.
We
are
basically
currently
working
also
on
this
problem,
but
and
on
the
problem
of
in
lesion.
What
is
lesion
so
basically,
lesion
is
a
JavaScript
framework
for
building
extended
web
applications.
Okay,
that
that
is
a
library
of
crd,
something
that
we
call
Delta
CR
disease,
but
it's
not
they're
more
more
or
less
is
a
close
to
Delta
C
and
it
is.
A
But
there
was
a
small,
the
small
difference
and
you
you
you
guys
can
can
access
to
lesion.
So
we
have
a
web
page
where
we
have
where
you
have
a
demo.
Ok,
so
these
these
these
clients
have
years
here,
duties,
I,
think
it's
just
it's
visible
like
it.
So
the
the
clients
in
the
web
browsers
connect
via
web
RTC
and
basically
you
can
execute
concurrent
operations
and
merge
and
we
have
here
this
demo
and
let
me
get
back
to
my
presentation.
A
So
this
this
is
a
this
is
a
we
have
a
library
of
this
year,
DTC
in
JavaScript,
so
this
might
be
interesting
for
for
Peru
and
something
that
will
through
mainly,
that
is
about
two
versions
of
see
oddities.
And
how
can
you
know
where's,
then
what
so?
We
worked
a
little
bit
on
that
so
I've,
just
added
this.
A
Just
before
the
the
presentation,
as
I
was
seeing
the
Pettis
presentation
so,
for
example,
swift
cloud
in
swift
cloud,
we
have
see
oddities
where
you
can
basically
go
in
into
the
sea
LEDs
and
ask
for
a
given
version
of
the
CR
DT
or
check
all
the
pressures
that
were
given
by
some
some
client,
and
so
we
have.
We
have
worked
a
little
bit
on
that
so,
and
it
is
I
finish.
My
presentation.
A
B
A
For
example,
so
so,
basically
the
question
is
whether
we
need
foo
a
morphic
encryption
or
if
we
can
use
something
that
is
lighter
than
for
morphic,
and
this
is
for
for
some
data
types
we
can
use.
You
might
not
use
fully-armed
amorphic,
for
example,
for
sets.
If
you
want,
where
can
instead
of
having
the
term
is
except
you,
you
are
good
with
a
probabilistic
set
with
a
very
low
probability.
For
example,
you
can
use
a
bloom
filter
for
for
recording
the
almonds
in
the
depths.
That's
that's
that's
enough,
for
example,
for
assets.
C
C
I'm
curious
as
to
what
happens
when,
when
some
of
these
a
lot
of
the
COTC
settings
are
a
few
replicas
than
clients
we're
evaluating
settings
where
we
have
like
millions
of
replicas,
because
we
want
like
client
oriented
things
and
those
causal
chains
get
really
messy
so
curious
if
you've
evaluated
those
council
settings
or
most
of
the
settings
kind
of
you
know,
low
bounded,
replicas
numbers.
So
we
we.
A
Do
not
bound
on
the
number
of
clients
we
can
have
as
many
clients
as
you
want,
but
you
know
in
our
approach.
We
assume
that
there
is
a
server
and
network
with
causal
cause.
Basically,
we
have
two
works
on
this
one
that
I
presented.
We
assume
that
there
is
a
backbone
and
all
the
kinds
synchronized
through
the
through
the
background.
Okay,
the
background
is
as
multiple
replicas
multiple
servers,
but
there
is
a
still
a
backbone
with
a
limited
number
of
clients
of
replicas,
but
the
number
of
clients
can
be
as
as
many
as
you
want.