►
From YouTube: Cassandra Community Webinar | Getting Started with Apache Cassandra with Patrick McFadin
Description
Slides: http://www.slideshare.net/planetcassandra/cassandra-20-introduction-use-cases-29122759
Abstract
Patrick McFadin (@PatrickMcFadin), Chief Evangelist for Apache Cassandra at DataStax, will be presenting an introduction to Cassandra as a key player in database technologies. Both large and small companies alike chose Apache Cassandra as their database solution and Patrick will be presenting on why they made that choice.
Patrick will also be discussing Cassandra's architecture, including: data modeling, time-series storage and replication strategies, providing a holistic overview of how Cassandra works and the best way to get started.
About Patrick McFadin
Prior to working for DataStax, Patrick was the Chief Architect at Hobsons, an education services company. His responsibilities included ensuring product availability and scaling for all higher education products. Prior to this position, he was the Director of Engineering at Hobsons which he came to after they acquired his company, Link-11 Systems, a software services company. While at Link-11 Systems, he built the first widely popular CRM system for universities, Connect. He obtained a BS in Computer Engineering from Cal Poly, San Luis Obispo and holds the distinction of being the only recipient of a medal (asanyone can find out) for hacking while serving in the US Navy.
A
All
right
and
it's
evening
here
Friday
evening
here
in
California,
we
are
coming
to
you
live.
This
is
not
a
recording.
So
what
we're
going
to
do
here
is
I'm
going
to
I'm
going
to
do
an
introduction
are
Patrick
Cassandra
and
you
have
a
Q&A
button
or
Q&A
panel
that
you
can
type
in
your
questions.
If
you
have
questions
as
you
go
along
I'm
going
to
just
go
through
this
and
at
the
end
we'll
do
the
QA
session
and
that'll
be
when
you
can
type
in
your
questions
and
we'll
try
to
get
through.
A
Most
of
the
qui
can
I
know,
there's
a
lot
of
people
here
and
it's
really
tough
doing
it
typing
it.
This
way,
I
would
I
hope
someday
we're
going
to
actually
talking
about
doing
this
in
a
different
way
as
well,
where
we
can
be
a
little
more
interactive,
but
hopefully
you'll
get
some
good
information
tonight
or
today.
Sorry
and
you'll
learn
a
little
bit
about
Cassandra.
So
let's
go
ahead
and
get
started
here
so
start
there
we
go.
So
this
is
the
this.
A
B
B
A
A
What
I
I
think
is
interesting
as
the
applications
that
you
write
with
up
with
Cassandra,
because
those
applications
are
going
to
be
a
lot
different
and
they're,
probably
going
to
be
up
a
lot
and
they're
going
to
be
highly
scalable,
so
I
talked
about
applications.
Not
is
the
alchemy
did
that
some
here
I
mean
my
background
is
an
architect
so
I've
done
development
I've
been
an
Oracle
DBA,
but
as
a
software
architect,
I
like
to
put
pieces
together
and
I
think
data
stacks
and
Cassandra
makes
that
work
really.
A
Well,
it's
just
one
piece
of
the
puzzle,
so,
let's
get
into
it
Cassandra.
Where
is
this
all
started
from
Cassandra,
has
been
around
for
five
years,
which
is
not
a
long
time,
but
for
some
of
the
newer
technology
that
we've
seen
in
the
past
few
years.
This
is
one
of
the
longer
ones
so
July
2008
is
when
point
one
of
faith
at
Facebook
was
a
co-founder
of
Facebook
which
bill
put
into
open
source.
So
that's
not
been
a
long
time
that
you
can
see
the
progression.
A
Cassandra
has
gone
from
point
one
in
July
of
oh
eight,
all
the
way
up
to
2.0,
which
just
got
released
a
couple
months
ago
and
will
have
two
dot
one
coming
here
shortly
in
January.
So
this
is
a
very
fast-moving
project,
which
means
that
there's
a
lot
of
exciting
things
going
along,
but
more
importantly,
is
that
it
has
a
lot
of
momentum,
lots
of
companies
behind
it,
big
companies,
probably
companies
that
you
work
at
I,
saw
some
names
out
there.
That's
on
netapp
on
somebody,
the
name.
A
As
you
know,
these
are
companies
that
use
Cassandra
quite
a
bit
of
Cassandra,
because
it
does
a
lot
of
things
that
they
need
it
to
do,
and
I'm
going
to
explain
what
that
is,
so
why?
Why
would
you
even
use
Cassandra
in
the
first
place?
There's
so
many
database
choices
out
there
and
what
is
it
about
this
one?
That's
going
to
make
your
development
architecture
and
operations
life
better.
A
This
is
my
simple
statement.
It
is
the
best
persistence
tier
for
your
application,
so
think
about
that
from
you
know,
from
your
building
application
standpoint,
what
what
can
you
do
to
get
the
best
out
of
anything
well
I
feel
like
Cassandra
is
the
best
for
this
because
of
what
it
does
that
matches.
What
you
need
your
application
to
do
again,
let's,
let's
figure
out
so
let
me
explain
what
Cassandra
can
do
for
your
application
and
then
maybe
hopefully
you
believe
what
I'm
saying
here.
A
So,
let's
get
into
a
brief
introduction
to
Cassandra,
it's
like
I,
said
started
was
actually
built
at
Facebook
and
originally,
but
it
goes
back
a
little
farther
than
that
the
Cassandra
was
built
on
a
couple
of
concepts.
The
first
was
the
Dynamo
paper
from
Amazon
and
the
Dynamo
people
was
about
building
a
shared,
nothing
architecture
of
a
database,
so
one
that
is
highly
scalable,
that
it
is
consistent
and
has
a
lot
of
scaling.
A
So
the
those
three
things
are
really
important
to
Amazon
because
of
their
building
up
this
global
infrastructure
and
at
the
time
they
were
using
a
a
lot
of
Oracle
and
had
a
lot
of
difficult
to
scale
horrible.
Beyond
a
single
data
center
and
even
inside
the
same
data
that
are
you're
going
to
run
into
limits,
where
you
have
to
do
things
like
shard,
so
they
were
looking
at
the
next
generation.
What
are
we
going
to
do?
The
dynamo
paper
is
really
amazing
because
it
was
built
on
20
Ford
in
the
site.
A
They
cited
24
different
papers,
academic
papers
and
the
dynamic
paper
itself,
so
this
was
computer
science
thinking
that
goes
back
to
the
1970s,
so
companies
like
IBM
and
digital
equipment
and
Sun
I
mean
these
are
big
companies
that
contributed
to
the
had
these
papers.
Academic
papers
that
contributed
overall
to
what
dynamo
is
so
when
Casandra
first
was
started,
it
was
Dynamo
was
a
key
value
store.
That
was
what
the
original
paper
was
about.
A
key
value.
Well,
the
key
value
store
is
not
very
rich.
A
When
it
comes
to
data
model,
it's
it's
very
difficult,
sometimes
to
translate
things
they
say
like,
if
used
in
relational
databases
from
certain
normalized
form,
key
value,
storage,
things
very
hard,
so
a
big
table,
Google
BigTable,
with
another
concept.
Added
to
this,
the
Google
BigTable
is
about
one
row
that
has
multiple
columns
tons
of
columns
billion
columns,
so
it's
a
very
different
data
model
than
key
value.
Obviously,
so
BigTable
is
put
a
blended
with
Dynamo.
A
So
now
we
have
is
a
dynamo
model
of
distributing
data,
but
it
has
the
BigTable
architecture
or
data
modeling
architecture
with
it
a
big
table
is
shared.
Dynamo
has
a
lot
of
other
databases
that
came
about,
for
instance,
react
and
Voldemort
or
databases
that
are
built
on
the
Dynamo
paper.
Bigtable
has
other
database
we
built
on
it,
which
is
includes
Cassandra
and
HBase,
so
these
are
not
Singleton's
they're
used
in
various
forms
in
different
database.
A
Kassandra
just
happened
to
blend
these
two
together.
So
what
about
that?
How
does
this
work
so
the
thing
about
the
standards?
It's
really
not
made
for
a
single
system.
You
could
build
a
single
system
and
it
worked
just
fine.
The
concept
of
a
cluster
is
really
important,
so
a
cluster
is
so
you
have
all
these
nodes
out
there
that
are
going
to
be
participating
and
those
nodes
are
going
to
have
to
work
together,
and
this
is
the
concept
of
shared-nothing.
A
So
each
node
is
independent
from
the
others,
but
you
can
add
or
remove
those
nodes
as
you
need,
and
that's
that's
how
the
scaling
story
works
and
I'll
show
you
some
of
that
in
a
minute.
But
that's
that's
a
critical
part
if
you
need
more
capacity,
should
just
be
able
to
add
more
nodes
and
scale
accordingly
Cassandra.
This
is
the
linear
scaling
system.
When
you
add
more
nodes,
you
get
more.
You
double
your
nose.
A
These
double
your
capacity,
it's
that
simple,
and
that
makes
it
for
very
easy
and
operation
sense,
and
also
very
easy
for
people
who
are
writing
code.
Hey
I,
don't
know
how
good
this
application
is
going
to
be,
but
I
hope
it
goes
huge
and
whenever
it
does
go
huge,
you
can
just
scale
your
notes
accordingly.
Now
how
does
this?
How
does
this
replication
story
work?
A
Well,
the
each
node-
let's
say
I'm,
going
to
talk
about
my
four
node
cluster
here,
so
each
node
is
going
to
own
25%
of
the
data
in
a
four
node
cluster.
So
as
a
total
cluster
goes,
I
have
a
hundred
percent
of
my
data.
Each
node
is
going
to
take
1/4
of
that,
so
25
percent
each.
So
each
node
now
has
25
percent
25
percent
25
percent
and
25
percent,
and
that
that's
how
we're
distributing
the
data
around
mm-hmm.
B
A
How
that
works
is
that
we
use
a
token,
and
that
token
is
a
hash
of
md5,
am
irma
by
a
murmur
three
hash
and
it
takes
the
row
key,
the
primary
key
that
you
give
it
and
it
assign
it
hashes
it
into
a
consistent
hash
and
then
each
node
is
assigned
a
range
of
tokens.
So
when
a
client
sets
data
into
the
cluster,
it
will
pick
which
node
needs
to
get
that
data,
that's
how
we
distribute
it
in
an
even
fashion.
A
A
B
A
We
go
so
each
each
node
is
going
to
be
written
to
and
read
from.
So
let's
talk
about
the
right
path.
This
is
one
thing
that
I
feel
is
a
critical
knowledge
point
in
Cassandra,
because
it
is
so
simple
how
it
writes.
Data
now,
like
I,
said,
I
have
an
Oracle
background.
Writing
data
into
an
Oracle
database.
Would
not
look
there
simple.
A
It
is
very
complicated
because
we
have
things
like
the
query
parser
in
a
cost-based
optimizer
and
then
all
the
things
that
happen
on
the
storage
side,
which
is
including
index,
writes
redo
logs
and
a
few
other
things
so
that
the
right
paths
in
a
relational
database
is
much
more
complicated
and
sometimes
that's
that's
needed,
because,
if
you're
requiring
acid
clients
or
something
like
that,
there's
a
lot
that
needs
to
happen.
It
can't
just
happen
on
the
fly,
but
the
way
Cassandra
works
is
not
it's
not
sketchy
either.
It's
not
crazy.
A
It's
just
a
very
simple
system,
and
it's
elegantly
simple.
So
let
me
explain
how
it
works
so
when
a
client
writes
data
to
a
Cassandra
node.
So
this
is
my
client
up
here
in
the
left.
When
it
writes
it's
going
to
write
a
row,
it's
going
to
give
a
row
key
and
some
kind
of
column
name
and
the
value,
and
it's
going
to
say,
here's
my
data
and
sends
it
to
the
node.
Now
the
upper
part
of
this
is
loops.
The
upper
part
of
the
line
is
the
server
part.
A
This
is
running
in
a
Java
Virtual
Machine
Cassandra
is
written
in
Java
and,
as
the
write
comes
in,
it
will
go
de
mediately
down
to
the
file
system,
and
this
is
a
commit
lock
right
here
on
the
left.
So
this
is
an
append-only
log
and
the
data
that
that
mutation
is
written
directly
into
the
commit
lock.
This
is
what
this
is
our
first
step
of
durability.
A
Once
it's
on
the
commit
log,
it
will
also
then
be
written
into
what's
called
the
mem
table,
which
is
a
representation
of
the
storage
row
and
that's
in
memory
in
Java.
So
now
we
have
it
written
Durham
to
disk.
We
have
it
now
in
Cassandra
itself
in
the
storage
engine
and
then
the
acknowledgement
goes
back
to
the
client.
A
We
have,
let's
see
that
it.
We
have
seen
sustained,
writes
in
clusters.
You
know
close
over
a
million
writes
per
second,
and
that's
that's
part
of
the
I
think
the
original
lure
of
TIF
Sanders,
because
it
can
do
these
really
high
rights,
but
it
can
also
do
a
lot
of
reads.
I
just
did
recently
did
some
performance
testing
with
some
HP
servers
and
they
were
doing
50
50
reads
and
writes
are
exactly
the
same,
so
our
read
speed
of
getting
pretty
close,
so
we
have
the
simple
right
path:
writing
data
as
quickly
as
possible.
A
Now
the
other
step
to
this
right
now,
once
we
have
this
data
in
memory
and
other
content
log,
this
is
the
this
is
the
disk.
The
other
side
of
the
disk
story
is
that
you
should
understand.
So
what
a
mem
table
is
written
in
memory,
so
the
JVM
stores
this
table
of
memory,
our
table
of
rows
and
that's
going
to
reach
a
finite
space.
If
you've
worked
with
the
JVM,
you
know
that
you
only
get
a
little
bit
of
heat
and
that's
going
to
take
only
so
much
of
your
overall
memory.
A
So
you
need
to
keep
the
heat,
keep
it
keep
moving
or
you're
going
to
run
into
garbage
collection
issues,
so
the
mem
table
gets
to
a
certain
size
based
on
the
JVM
size
and
then
once
it
gets
to
that
size,
it
will
then
flush
out
that
storage
row
in
its
entirety
to
the
disk.
That's
what
this
flush
part
is.
A
So
whatever
these
files
are
written
out,
eventually,
you're
going
to
run
out
of
disk
bases,
they
just
keep
flushing
on
tables
and,
if
not
updates
to
your
data,
come
along.
You'll
need
to
be
able
to
show
that
in
your
data
files
and
if
you're
not
updating
any
files,
you're
going
to
have
to
have
a
plan
for
that,
so
what
we
have.
Yes,
they
already
have.
How
do
you
update
a
row
so
when
that
row
of
data
sitting
in
memory
gets
a
new
piece
of
data?
A
Let's
say
you
update
like
the
first
name,
someone's
first
name
or
a
dollar
value
on
the
same
column
name.
Well,
that
means
that
there
is
already
data
on
the
in
the
data
file.
1Ss
table
area
has
old
data.
Now
you
get
a
new
data
point
inside
memory
now.
The
way
that
Cassandra
works
for
writes
is
that
the
last
right
wins
so
there's
a
timestamp
associated
with
each
write.
That's
that
on
the
client
side
and
when
that
timestamp
is
included.
That
means
that
whenever
we
read
data,
we
look
for
the
data
that
has
the
newest
timestamp.
A
So
what
can
happen
over
time,
though?
Is
you
now
once
this
mint
table,
with
the
newer
data
flushes
out
to
an
SS
table?
Now
you
have
two
SS
tables
with
that
same
column
of
data,
one
has
polar
data,
one
has
newer
data,
we
have
thing
called
compaction,
and
this
is
actually
from
BigTable
HBase
Business.
Anything
and
what
compaction
does
is
it
takes
multiple
SS
tables
brings
them
into
memory
does
emerge
short
and
then
what
happens
then?
A
Is
that
after
it
doesn't
merge
short,
it
then
writes
out
a
brand
new
SS
table
and
then
it
will
delete
the
old
SS
tables
once
the
new
one
is
rich
and
that
new
SS
table
is
going
to
be
a
little
bigger,
but
it's
also
going
to
be
merged
shortages
that
me
data.
So
if
you
have
an
old
right
and
a
new
right,
the
merge
will
then
eliminate
the
old
right.
You
leave
the
new
rest.
So
that's
how
you
keep
your
system
up-to-date
and
you
keep
the
tables
fresh
with
your
right
data.
This
happens
over
time.
A
So
when
you
have
a
lot
of
Rights
per
second
you're
going
to
have
a
lot
of
compaction,
that's
just
a
normal
part
of
Cassander
when
you're
running
Cassandra
as
an
operation
side.
That
is
what
your
optimize
for
is
learning
a
lot
of
compaction,
because
that's
keeps
your
your
data
files,
fresh
and
good
value,
keeps
your
system
working
efficiently,
which
is
what
we
want
and
it
keeps
the
reads
really
efficient
as
well.
So,
but
let's
talk
about
the
reads.
So
what
about
the
reads?
And
the
reads
are
a
little
more
we're
going
to
read
happen.
A
They're
a
little
more
complicated
because
there's
a
lot
more
going
on
there,
besides
just
writing
out
to
commit
log
and
amend
table.
So
what's
going
to
happen
here
is
the
name
of
the
game.
Here
is
when
we
do
a
read.
We
need
to
find
that
data
set
on
the
SS
table,
so
everything
is
optimized
when
I'm
finding
the
right
FF
table
with
the
data.
So
when
the
clan
TAS
were
again
the
row,
the
column
and
the
company
of
the
column
name,
it's
going
to
make
the
request.
The
first
stop
is
going
to
make.
A
Is
that
the
key
cache?
The
key
cache
is
going
to
be
how
it's
going
to
cache
the
key
the
row
key
that
you've
given
it
based
and
then
the
SS
table
that
it
belongs
to
so
hopefully,
if
that
is,
is
a
hit.
The
key
cache
will
say:
okay,
you've
been
given
this
row
key.
Here's
the
data,
here's
the
FS
table
that
that
is
belongs
to
so
that
would
give
you
a
single
seek
on
the
disk.
Now,
if
you
don't
have
a
situation
where
you
get
the
key
cap,
you
have
a
key
cache.
A
Miss
then
we're
going
to
jump
over
to
the
bloom
filters
now
in
bloom
filter
is
a
data
structure
of
the
probabilistic
data
structure
and
it's
per
SS
table,
and
we
ask
each
one
of
those
FS
table
bloom
filters.
Is
this
row
key
yours
and
the
idea
of
the
bloom
filter
is
to
find
out
where
the
data
is
not
where
it
is.
So
we
eliminate
a
lot
of
the
Sikhs.
A
It
would
happen,
you
can
imagine
if
you
had
a
thousand
SS
tables
and
you
had
and
you're
looking
for
loci
of
data,
you
would
want
to
scan
over
a
thousand
rows
thousand
SS
tables.
That
would
kill
your
performance,
so
the
bloom
filters
job
is
really
to
say.
Okay,
how
can
we
get
this
down
to
the
minimum
amount
of
the
minimum
amount
of
SS
table
leaves,
and
if
you
tuned
properly,
you
should
be
able
to
get
one
or
two
seats
on
your
data,
which
is
very
efficient.
A
Thinking
about
this
from
a
disk
standpoint,
if
you
do
a
Asik
on
disk,
if
you're,
using
something
like
SATA
or
a
Shazz
disk
you're
in
the
millisecond
range,
so
that
can
count
up
fabs
disk
can
do
about
five
milliseconds
per
seek.
So
if
you
had
to
do
five
seeks
to
get
to
that
data
you're
at
25
milliseconds
in
just
this
time,
we
want
to
minimize
that
as
much
as
possible
with
SSDs.
A
It's
not
as
much
of
an
issue
because
with
s
receives
your
seat
times
in
microseconds
and
that
doesn't
add
up
real
quick
and
matter
of
fact,
I
recommend
FS
B's,
often
especially
where
read
performance
is
very
important.
We
can
do
SS
table
reads
and
the
repast
on
empathise
really
efficiently.
So
once
the
bloom
filter
or
the
key
cache
finds
the
proper
FF
tables
that
FF
tables
read
into
memory
and
then
acknowledgement
goes
back
to
the
client
with
the
data.
So
there's
a
little
there's
a
couple
of
steps
in
there.
A
So
the
speed
is
really
important
and
so
I
I
have
this
real
user
story,
the
brand-new
app
out
there
they
had
SSDs
installed.
They
were
doing
a
2.5
million
requests
per
hour,
I
think
it
was
per
hour
per
minute
and
maybe
every
minute
and
they're,
but
they're
p99
they're
they're
99th
percentile
for
3.17
in
the
world
cycles.
They
were
really
doing
well
and
that
that
shows
you
that
the
reads
are
not
a
second-class
citizen
in
Cassandra
reads
are
very
important,
and
this
is
actually
one
thing.
I
spend
a
lot
of
time.
A
Working
with
users
is
optimizing.
The
read
partition
so
that
we
can
get
the
really
fast
read.
I've
worked
with
customers
to
get
less
than
a
middle,
so
I
can't
read,
it
is
doable
and
it's
just
part
of
the
system
is
the
understanding.
Oh
I
need
to
have
a
good
compaction.
My
key
cache
needs
be
accurate.
My
balloon
soldiers
need
to
be
up-to-date,
and
my
data
model
needs
to
be
able
to
express
that.
So
these
are
all
things
that
you
can
learn
along
the
way
with
Cassandra
okay.
So
now
we
have
a
weeds.
A
We
have
a
right,
let's
go
into
what
happens
with
that
data
whenever
it
gets
to
that
single
node.
Now,
when
they're
on
a
single
node
that
doesn't
work
so
good,
because
what
happens,
then,
if
that
you
have
a
potential
single
point
of
failure,
so
we
don't
want
to
leave
your
data
on
one
node.
If
that
node
was
to
crash
and
I
saw,
somebody
says
a
JVM
crash
yeah.
What?
If
your
JVM
crashes,
you
know
that's
a
bad
thing
right,
because
that
means
that
all
the
data
to
within
memory
gets
flushed
is
gone.
A
A
So
replication
of
the
core
part
is
a
dynamo
paper,
and
so
how
this
works
is
that
we
have
each
data
is
responsible
for
a
primary
range
of
data,
so
say
20
that
25%
of
data
now
we're
going
to
say
we're
going
to
apply
a
replication
factor
of
3
to
this
particular
cluster,
meaning
that
we
need
three
copies
of
our
data.
What
that
means
for
cassandra
is
that
there'll
be
the
first
copy
will
be
on
the
primary
and
then
the
adjacent
secondary
will
have
a
copy,
and
then
the
next
adjacent
will
have
a
copy
as
well.
A
So
now
we
have
three
copies
of
this
data
and
this
is
done
asynchronously
and
it
replicates
they
synchronously
where
the
data
is
written
and
this
replication
factor
will
mean
that
now
each
node
has
three-quarters
of
the
data
in
the
cluster
on
it.
With
these
three
nodes
having
the
data,
you
could
leave
as
one
of
these
nodes
and
still
have
all
of
your
data
in
your
cluster
and
that's
really
important,
because
if
you're
trying
to
have
any
uptime
chance
about
time,
you
need
to
be
able
to
survive
a
single
node
failure
or
even
two
node
failure.
A
Nodes
like
that
will
go,
come
and
go.
You
see
it
all
the
time
and
we
just
can't
get
away
from
the
fact
that
hardware
will
fail.
The
data
centers
are
going
to
fail.
It's
just
going
to
keep
happening
so
why
not
build
systems
distributed
in
a
way
that
will
tolerate
that.
So
here
we
have
three
copies
of
our
data,
and
this
brings
up
the
next
concept,
which
is
works
hand-in-hand
with
replication.
So
now
we
have
this
of
consistency
because,
as
a
programmer
as
an
architect,
I
have
a
concert'
need
now
a
Cassandra.
A
You
get
this
idea.
You
have
this
idea
of
eventual
consistency,
there's
plenty
of
talks
on
eventual
consistency
you
can
go
to,
but
let's,
let's
get
into
that.
What
that
really
means,
if
it's
used
in
a
negative
way,
I
can
understand
people
don't
want
to
have
their
data
show
up
eventually
like
it
will
be
there
next
week.
That's
not
the
case.
The
consistency
level
is
what
you
have
as
a
tool
of
the
programmer
to
set
that
consistency
level
in
a
way
that
matches
what
you
want
near
data.
But
again
this
is
from
an
application
standpoint.
A
What
if
your
application
requires
the
consistency,
level
and
consistently
level
mean
how
many
nodes
acknowledge
the
right
that
I've,
given
it
or
the
read
that
I'm
asking
for
and
that
consistency
level
is
set
per,
read
or
write?
That's
part
of
the
request,
but
when
I
write,
data
I
say
I
would
like
a
consistency
level
of
and
those
consistency
levels
are
different.
We
have
a
whole
bunch
of
different
ones
that
you
can
do
so,
for
instance,
the
top
one
is
all
so.
A
If
I
have
three
replicas
and
I
write
data
to
my
cluster,
then
I
expect
all
of
the
replicas
to
acknowledge
that
they
have
committed
that
data
to
disk
and
that
my
gate
is
safe
before
I
return.
Anything
back
to
the
client
and
the
client
wants
to
get
to
return
on
a
consistent
level.
All
know
that
everybody
has
the
data,
there's
no
eventual
consistency
at
that
point.
It's
all
consistent,
but
that's
the
highest
level
consistency.
You
can
ask
for
now
my
diagram
here.
A
Let
me
point
out
another
concept
too,
as
well
is
that
each
node
the
system
is
independent.
The
client
can
read
a
way
to
any
note
if
you
want
you,
and
that
means
that
there
is
no
coordinator
or
a
sorry
master,
there's
no
elective
negative.
Anything
like
that
in
this
system.
That
is
a
huge
way,
huge
win
on
up
time,
because
if
you
have
a
master
node
or
a
master-slave
replication
synchronous
replication,
that's
going
to
break.
There
are
many
systems
out
there
that
do
play
based
on
that,
we
will
lose
data
if
you
have
that.
A
So
that
means
it
was
a
client
what
it
writes
data
to
any
one
of
the
nodes
that
node
then
will
either
save
it
data
locally
or
act
as
a
coordinator,
meaning
that
the
note,
if
the
note
get
some
data
and
it
gets
a
row
key,
it
says-
oh
well,
that's
not
my
data,
that's
a
different!
That's
a
different
brocade
I'm,
not
the
hashes
of
mine,
but
I,
know
where
to
send
it
if,
for
instance,
or
client
writes
to
node
4.
A
Well,
if
that
node
doesn't
responsible
for
that
data,
either
the
left
or
the
primary,
then
it
will
send
it
right
out
to
the
other
nodes
on
behalf
of
the
client.
So
it's
coordinating
that
right.
So
if
that
node
4
was
to
go
down
at
any
point,
the
client
would
get
a
timeout
and
just
retry
on
one
of
the
other
nodes
and
still
write
its
data.
So
this
keeps
the
system
live.
This
keeps
your
client
happy,
because
now
you
have
time
that,
because
we
don't
have
any
nodes
that
are
I
mean
you
don't
have
that
cluster.
A
How
to
availability!
You
haven't
know
that
one
offline,
but
that's
not
going
to
bring
down
the
whole
system.
So
this
this
consistency
level
is
managed
somewhat
by
the
by
the
coordinator.
So
the
next
level
down
I'm
going
to
point
out
is
corn
in
quorum
is
where
we
mostly
write
in
read
from,
and
that
means
that
51
percent
of
the
replicas
acknowledge
that
you
have
gotten
the
data.
A
So
in
this
case
with
this
example
that
I've
written
here,
the
client
writes
and
says:
I
want
a
consistency
level
core
node
4
is
not
the
primary
node
for
that
data.
Is
it
a
replicator,
so
it
will
coordinate
the
write
in
parallel
asynchronously
to
3
of
the
nodes,
the
primary
in
the
two
replicas.
Now
the
primary
returns
back
in
5
microseconds
that
second
one
of
the
replicas
comes
back
at
12
microseconds.
But
then,
though,
3
is
really
slow.
It's
something
going
on,
maybe
been
someone's
formatting,
something
or
there's
a
garbage
measure.
A
Who
knows
well,
and
it's
going
to
set
that
native
500
microseconds?
So
that's
a
lot
longer
than
the
other
two
well,
because
I
asked
for
a
quorum.
That
means
that
I'm
not
really
too
concerned
about
the
third
node
being
slow.
I
got
two
acknowledgments
I'm
going
to
acknowledge
back
to
the
client
and
say
yeah
we're
good
to
go
within
12
microseconds
that
500
microseconds
second
act.
A
Acknowledgement
will
still
happen,
but
it's
not
a
requirement
for
the
client
to
get
a
positive
response
back,
which
is
pretty
important,
because,
if
you're
trying
to
keep
things
moving,
you
need
to
be
able
to
tolerate
one
slow
node
and
that's
one
of
the
funny
tenets
about
distributed
computing.
It's
that
ace
local,
a
slow
node
should
not
be
a
dead
note.
It
should
not
be
treated
in
the
exact
same
way
and
sometimes
it
is
and
we
will
with
core.
So
this
is
also
available
on
reads
as
well.
A
So
if
I'm
reading
data
from
my
cluster
then
I
say
here,
I
need
my
data
and
it
will
ask
all
three
nodes
and
when
two
nodes
have
come
back
with
with
a
consensus
answer,
it
will
return
back
to
the
client.
If
I
have
one
of
the
notes
they
offline,
then
you're
not
going
to
have
you're
not
going
to
have
to
worry
about
that
from
the
client
side.
This
is
what
keeps
you
online
for
a
long
time.
We
have
it
blue
Yala,
which
is
the
customer
here
in
the
US
and
they're
big
cassandra
using.
A
You
may
have
seen
some
of
their
talks.
We
all
is
a
big
internet
video
site
and
they
have
had
a
Cassandra
clusters
up
with
three
years,
they've
been
up
for
three
years
and
never
gone
down,
and
that's
the
kind
of
uptime
we
would
expect
and
how
that
survives
is
that
if
you
have
say
four
nodes
and
you're
writing
at
quorum
and
reading
a
quorum,
you
can
survive
one
node
going
offline
for
whatever
reason
that's
important,
especially
because
we
we
have
to
bring
down
nodes
all
the
time
right.
A
When
I
worked
in
ops,
we
had
to
reboot
nodes,
we
had
to
reboot
servers
all
the
time
and
yeah
they've
got
a
good
question
on
that.
So
why
do
you
need
to
read
for
more
than
one
node?
That's
a
good
question,
because
what
what
can
happen
is
that
let's
say
that
one
of
those
one
of
those
nodes
was
offline
or
got
an
error
on
the
read.
We
want
to
see
to
make
sure
your
data
is
absolutely
consistent.
A
You
want
to
be
able
to
read
from
all
the
replicas
if
you
can,
and
that
gives
you
the
consistency
level
saying.
Okay,
these
two
nodes
agree
now
one
would
slay
slower
and
wasn't
setting
the
data
to
staff
and
had
older
set
of
data.
The
first
two
would
give
the
correct
answer,
and
the
third
one
would
give
incorrect
answer.
A
A
B
A
B
B
A
I'm
just
going
to
start
there
again,
so
a
read
and
write
at
one
means
that
you
only
ask
one
replica
for
an
acknowledgment
you're
not
asking
for
all
those
for
an
acknowledgment,
and
so
it
could
be
a
lot
faster
because
then
you're
not
waiting
for
others
to
respond,
and
so
you
have
this
latency
problem
say
like
with
one
note
or
two
nodes:
one
node
will
be
a
lot
faster.
One
could
be
a
lot
quicker
overall.
A
That
is
not
your
best
consistency
level.
If
you're
waiting
for
say
like
something
very
important
that
you're
you
know,
you'll
need
the
higher
level
of
consistency,
but
it
does
fit
a
surprising
number
of
applications
that
one
is
just
fine.
It
really
is
up
to
use
on
your
application,
but
as
a
programmer
or
even
an
architect,
you
get
to
pick
the
consistency
level.
Sometimes
you
may
want
to
write
at
one
and
read
a
corm.
You
can
mix
and
match
those.
That's
perfectly
fine.
A
So
here's
the
here's,
the
benefit
and
I
saw
someone
asked
this
question
earlier
about
whether
or
not
nodes
one
knows
go
down.
So
let's
talk
about
the
single
node
failure
issue,
a
single
node
failure
is
all
about
resiliency,
because
this
is
what
we
plan
for
and
if
we
have
a
replication
faster,
factoring
consistent
to
the
level
set
up
properly,
then
we're
going
to
be
okay
and,
like
I
said
earlier,
I
been
in
playing
situations.
I
need
to
reboot
a
server
I've
upgraded
as
the
operating
system
I
need
to
put
in
a
security
patch.
A
Anything
can
happen,
move
the
actual
server
to
another
rack.
All
of
these
things
happen.
It
should
not
bring
down
my
entire
system,
so
I
like,
in
this
case
I've
chosen
with
my
four
node
cluster,
which
was
a
small
cluster,
a
replication
factor
of
three
and
I'm,
going
to
do
all
my
reads
and
right
to
quorum.
That
means
that
I
can
lose
a
single
node
or
shut
it
down
and
move
it
without
bringing
any
any
bad
things
to
my
client
client
will
be
reading
and
writing
to
the
cluster
without
any
issues.
A
Now
what
happens
is
is
that,
as
that
servers
offline,
things
will
be
still
be
written
and
read
from
the
cluster,
but
when
that,
when
that
node
goes
offline,
the
nodes
of
coordinating
nodes
that
are
getting
rights
for
that
node
will
then
say:
okay,
hey!
You
know
what
that
node
is
offline,
I'm,
going
to
store
its
data
and
we're
called
on
a
hint,
so
it
will
store
the
data
that
should
be
destined
for
that
that
offline
node,
while
the
node
is
offline.
A
Now,
while
the
node
comes
back
online,
you
reboot
server,
then
it
will
replay
all
the
hints
into
that
server
went
and
basically
bring
it
back
up
to
consistency,
the
proper
consistency
level
and
then
that
node
will
then
add
itself
back
into
the
cluster
and
Riaan
part
of
the
cluster.
Again
so
little
things
like
going
offline
and
coming
back
online,
that's
handled
and
the
system
is
ready
for
that
and
by
storing
hints
and
by
using
a
protocol
we
call
gossip,
which
is,
it
shows
the
state
of
the
cluster.
A
We
know,
okay,
that
was
offline,
I'm
going
to
hold
on
to
its
data.
Oh
it's
back
online.
Here's
your
data!
This
is
keeps
the
operation
very
easy,
and
it's
typical,
very
typical
to
have
backups
and
things
like
that
going
on
in
a
large
operating
cluster,
or
you
bring
the
server's
down
up
and
down
all
day,
long
and
I
and
that's
a
very
different
way
of
doing
business.
A
So
here's
my
absolute
favorite
feature
of
Cassandra
ever
and
that
is
the
replication
across
the
wind.
So
this
is
I
heard
this.
This
week,
I
was
working
with
a
user
team,
a
really
big
team,
and
they
they
were
just
like
the
replication
between
when
replicating
a
replication
between
data
centers,
the
Cassandra
can't
be
beat
it's
the
only
game
that
can
do
this
as
good
as
a
can't
and
I
have
to
agree.
This
is
one
of
the
reasons
I
started
using
Cassandra
and
this
is
a
part
of
dynamo.
A
So
what
I
mean
by
that
is,
if
you
have
a
cluster,
you
can
span
multiple
geographies,
so
you
can
have
your
partier
cluster
in
India
and
another
part
in
say,
Europe
or
maybe
in
US,
and
that
data
and
I've
actually
worked
with
a
customer.
That
is
doing
that.
That's
the
DreamWorks
DreamWorks
has
of
data
center
in
India
and
a
data
center
in
Los
Angeles,
and
that
data
is
replicated
between
the
two
places.
Now
that
is
pretty
amazing,
considering
how
hard
it
was
to
do
with
Oracle.
A
They
really
had
a
hard
time
you're
using
Golden
Gate,
and
it
wasn't
working
as
well.
So
now
what
they
have
is
a
standard
cluster
that
spans
over
two
countries.
The
when
link
between
them
is
this:
where
y'all
the
replication
happens,
but
this
is
what
makes
Cassandra
so
good
at
this
is
that
the
synchronization
is
very
simple
and
is
asynchronous.
So
when
a
client
writes
data
into
a
local
set
of
nodes
in
a
cluster,
there
is
a
data
center
awareness
is
topology
aware.
A
So
when
a
node
adds
itself
into
the
cluster,
it
knows
which
data
center
it's
in.
It
knows
which
rackets
in
so
when
things
like
replication
occur.
It
knows
oh
I
need
to
if
I'm
receiving
data
in
my
node
and
in
this
local
data
center
I
need
to
replicate
it
to
the
other
data
center.
So
if
a
client
writes
through
the
primary,
the
primary
will
then
coordinate
with
another
note
and
the
other
data
center
and
that
that
node
will
then
write
locally
to
all
the
other
replicas.
A
I
mean
I
bought
gigabit
pipes
before
in
data
centers,
because
I
had
to
replicate
so
much
data
on
my
EMC
arrays
and
that's
just
a
lot
of
data
to
move
around
with
Cassandra
is
not
that
bad
and
the
only
way
you're
going
to
be
able
to
copy
a
petabyte
of
data
is
a
little
bit
at
a
time
as
you're
writing
the
data
and
that's
what
I
see
users
doing
all
the
time.
So
in
this
case,
I
have
an
8
node
cluster
4,
which
are
in
each
data
center.
A
So
that's
how
we
describe
done
and
we
know
that
they
each
have
their
own
replication
factor
and
that
they're
separated
from
each
other
by
DC.
So
if
we
lost
the
link
between
those
two,
it's
still
both
be
online.
That's
a
critical
part
of
Cassandra
is
a
consistency
or
the
availability
during
a
partition
of
an
event.
That's
when
the
nodes
can't
see
each
other.
So
like
I
said
this
is
this
is
my
favorite
feature,
because
this
is
how
you
do
active
active?
This
is
how
you
have
the
maximum
of
time.
You
cannot.
A
You
cannot
have
the
best
uptime
by
just
putting
all
your
data
in
one
day
to
center,
because
the
data
centers
go
down
quite
often,
so
how
about
writing
some
code?
Let's
jump
into
that
real
quick.
So
we
have
data
stats.
The
company
we've
made
a
decision
a
while
back
to
go
ahead
and
write
those
to
make
the
drivers
part
of
our
company
and
provide
those
in
an
open-source
fashion.
A
So
now
there
are
plenty
of
clients
out
there
for
lots
of
languages
that
are
not
part
of
data
stacks,
but
I'm
just
going
to
point
out
a
few
of
ours.
So
right
now
we
have
Java,
we
have
C
sharp
and
we
ice
con
drivers
to
get
your
code,
get
your
data
in
and
out
and
that's
we
have
more.
Actually,
we
have
a
C++
driver
right
now
too.
A
B
A
A
running
cluster,
so
what
about
that?
How
do
you
connect
to
a
cluster?
Well,
that's
what
makes
it
really
cool
but
for
the
developer.
Is
that
once
you?
So
this
is
a
this
is
how
you
create
a
connection
using
the
Java
driver.
You
just
put
in
the
IP
addresses
or
of
the
notes
that
you're
going
connect
to
you
say
I'm,
going
to
connect
to
the
video
database.
Keyspace
you
build
a
cluster.
A
Add
some
contact
points
to
take
those
two
servers:
you
put
in
a
load
balancing
policy,
how
you're
going
to
write
that
data
and
then
you're
going
to
a
retry
policy.
If
there's
failure
build
at
that
point,
you
can
do
a
connect
to
the
session
now
create
a
session,
and
then
that
session
is
a
connection
to
the
cluster.
There's,
no
more
thinking
about
how
many
servers
are
in
there
and,
what's
really
cool
is,
if
you
add,
or
remove
servers
from
the
cluster,
it
will
adjust
itself
from
the
client
side.
A
There's
the
programmers
are
not
have
to
be
aware
for
that.
They
don't
have
to
I've
done
plenty
of
code
pushes
where
I
was
pushing
out
brand
new.
Let's
say
you
know
like
a
configuration
and
another
configuration
had
to
go
out
now,
here's
a
list
of
new
database
servers
or
something
like
that.
We
don't
have
that.
That's
not
that's
not
the
way
we
run
here.
B
A
See
here
so
what's
next,
so
let's
talk
about
cql
now,
if
you
can
connect
to
the
cluster-
and
you
can
do
something
with
it,
what
are
you
going
to
do
well?
Seek
you
out
is
that
is
the
language
that
you
would
use
to
talk
to.
Cassandra
Cassandra,
query
language.
It
looks
a
lot
like
SQL,
but
it
has
some
limits
to
it,
for
instance,
the
predicates
that
are
involved.
You
can't
do
so
selects
or
joins,
and
things
like
that.
A
So
we
still
have
enough
room
in
there
to
get
you
into
trouble
and
there's
some
there's
going
to
be
some
good
talk
on
that,
but
I'm
going
to
walk
you
through
just
the
basics.
I
have
a
lot
of
talks
on
writing
cql
and
how
to
do
it.
If
you
want
to
know
more
about
it,
but
for
now
let's
just
get
a
little
intro
into
how
you
write
data
to
the
database.
Let's
demystify
that.
So
from
the
data
model
standpoint
we
have
some
containers
that
you
need
to
know
about.
A
So
the
cluster
is
what
we've
been
talking
about.
This
is
what
contains
all
the
and
all
the
nose
across
the
land.
So
if
you
have
multiple
data
centers,
you
can
have
ten
data
centers,
that's
that's
your
entire
cluster
and
that's
everything.
The
key
space
is
what
is
a
container
of
all
the
calda
tables
and
that's
also
where
you
specify
your
replication.
So
if
you
create
a
key
space,
it's
like
a
database
in,
say
my
sequel,
Oracle.
A
What
you're
saying
is
alright.
Here's
my
specified
key
space
I'm
going
to
replicate
those
in
this
data
center
three
times
when
that
data
center
two
times
and
so
that
all
the
data
in
those
tables
will
be
replicated
in
that
fashion
and
then
the
tables
finally
are
just
like
what
we've
always
used
in
relational
databases,
a
table.
It
has
columns
and
rows
and
that's
the
basic
unit
of
data
storage
in
Cassandra.
B
A
A
That
would
give
you
some
give
you
a
programmatic
way
of
changing
the
way
you're
dealing
with
data
and
I'll.
Show
you
how
that
works,
but
an
insert
will
override
data.
Absolutely
an
update
may
append
data
in
some
cases
so,
for
instance,
the
the
key
violations
and
things
like
that
will
never
be
a
property
you'll.
Never
have
that,
like
you
do
with
Cassandra
or
with
a
relational
database.
Is
where
you
say:
try
to
override
a
row
key
and
as
a
primary
key
you're
not
going
to
get
that
situation
where
it's
going
to
say?
A
Oh,
you
can't
do
that
that
exists.
It
stopped.
It
won't
stop
you.
You
will
overwrite
data.
So
that's
something
you
need
to
be
aware
of
now.
There
is
a
way
to
stop
that
there
is
action
allottee
in
cql
that
you
can
do
it
if
exists,
but
you
have
to
overtly
ask
for
it.
You
can't
just
assume
that
if
you're
trying
to
overwrite
data,
it
will
stop
you.
You
have
to
be
very
clear:
I
don't
want
this
to
be
over
in
and
so
for,
updates,
there's,
never
read!
That's
how
it
works.
A
Is
that
then,
so
we
just
overwrite
the
same
data.
So
let's
look
at
the
table
creation
now
this
should
look
pretty
familiar
to
everybody.
This
was
similar
very
similar
in
many
ways
to
what
my
sequel
Oracle
does
for
inferior,
creating
tables.
So
I
have
this
Creek
table
user,
very
everybody
straight.
So
right
now,
I
should
point
this
out.
So
here's
username
it's
a
bar
chart.
What's
missing
from
that
bar
chart
this
size,
we
don't
have
size,
we're
not
putting
it
we're
not
specifying
the
amount
of
bytes
that
that
but
hold,
and
that's
what
I
think.
A
That's
the
first
stop
here
and
this
is
table
definition,
and
why
don't
we
just?
Why
don't
we
have
size?
And
that's
really
because
of
the
way
Cassandra
works,
it's
very
loose
in
the
amount
of
data
that
can
store,
but
it's
because
of
in
a
storage
and
we
store
as
much
data
as
that's
in
the
data
file
is
as
much
data
as
you
have
Oracle,
for
instance,
in
my
sequel,
bolt
and
toast
course
everybody
does
this
with
the
database
files
pre
allocate
space
and
the
data
files
for
the
type
of
data
that
you're
setting.
A
So
when
you
create
a
bar
chart
255
or
a
float
or
an
int,
it
allocates
X
amount
of
space,
byte
wise
inside
the
file
ready
to
go,
and
that's
where
you
did
in
the
block.
Fragmentation
and
things
like
that
with
Cassandra,
you
can
have
each
column
value
can
have
up
to
two
gigabytes
of
data
in
it.
That's
a
lot
of
data
now
I.
A
Suggest
doing
that
cuz
it
takes
a
long
time
to
set
to
gigabytes
of
data
because
it
just
takes
forever
to
strengthen
the
client,
but
that's
how
much
data
can
be
stored
when
that
data
is
set
on
the
disk.
It's
just
it's
a
sequential
array
of
bytes
and
that
there's
a
header
and
an
ending
it's
just
as
much
data.
A
Those
are
pretty
cool
because
they
give
you
a
gun
with
dynamic
variable
inside
of
a
statically
typed
schema
and
the
static
schema
will
give
you
validation
with
varchar',
but
then,
in
this
case,
I'm
going
to
need
to
have
multiple
shopping
carts.
This
keeps
you
from
having
to
create
multiple
fields.
You
can
just
have
a
set
of
those
feet
of
shopping
carts
and
then,
in
the
other,
in
the
shopping
cards
model
over
here.
A
A
It
will
be
only
one
in
the
database,
but
it
doesn't
stop
you
from
overriding
it
unless
you
ask
it
to,
but
that
primary
key
is
very
important
for
whenever
you
look
up
your
data
and
I
can't
get
into
I
would
do
this
for
hours.
If
we
got
into
a
data
modeling
discussion.
I
do
have
some
really
interesting
talks
and
anomalies
on
YouTube.
You
can
search
for
my
name
and
data.
Modeling
and
you'll
be
inundated
with
cool
videos,
because
I
have
a
lot
of
them
out
there,
but
I'm
going
to
cover
the
basics
here
with
you.
A
Primary
key
is
all
about
finding
locality
of
that
data,
but
also
uniqueness
of
those
records,
so
in
the
shopping
cart,
for
instance,
I
have
user
name
and
cart,
name
I'm,
combining
together
to
make
a
unique
key
for
locality.
That
gives
you
a
fast
lookup
item.
Id
will
give
you
uniqueness
inside
that
record
a
shopping
cart
record.
So
this
is.
There
are
some
very
interesting
combinations
you
can
do
but
again
getting
to
know
how
to
do.
A
Data
modeling
is
really
critical,
and
that's
probably
your
next
step
after
this,
and
luckily
we
have
pretty
training
for
this
and
I'll
show
you
that
in
a
minute,
so
inserting
data
again
very
similar.
So
what
you're
expecting
insert
into
users?
First
name
last
name:
email
password
creative
days.
These
are
all
this
is
syntax
for
creating
a
new
record
and
using
cql
our
driver
if
you're
using
Python.
These
are
all
very.
This
is
all
similar
syntax.
A
Think
about
how
much
there's
amazing
amount
of
data
that
is
time
series
and
how
fast
you
get
it
so.
Here's
a
good
example
I
like
this
example
a
lot
so
the
Peter
Higgs
and
Francois
angle.
They
born
the
Nobel
Prize
for
Physics.
This
is
a
few
like
a
couple
months
ago
or
a
month
ago
they
got
the
Nobel
Prize
for
Physics
and
it
was
for
the
the
theorizing
the
existence
of
the
Higgs
bosons,
which
is
a
particle
in
particle
physics
yeah.
A
This
is
some
pretty
crazy
science,
but
they
they
got
this
Nobel
Prize,
basically
because
they
found
the
Higgs
bosons
now
the
how
they
did
that
was
it
build
this
really
big
particle
collider
in
partial
sheen
and
France
and
Italy
and
Switzerland
all
over
the
place.
Right-
and
this
was
this-
is
the
CERN,
the
the
he
comes
to
know
that
Large
Hadron,
Collider
and
there's
in
this
collision
Bay
this
blue
thing
in
the
middle.
This
was
called
Atlas.
A
This
is
what
good
to
detection
on
all
those
collision
events,
the
data
that
was
in
that
was
created
from
that
was
enormous.
It
was
like
a
gigabyte
per
collision
and
there
was
a
massive
data
reduction
in
the
team
that
was
trying.
They
had
to
dig
through
all
the
data
to
find
this
particle.
Well
all
that
data
that
was
coming
out
of
this
at
that
enormous
speed.
With
all
that
time,
series
data
was
stored
in
this
thing
called
PBS,
which
I
think
is
a
really
cool
name.
Well,
PB
s--,
the
database
behind
that
is
cassandra.
A
This
is
the
only
database
they
found
that
could
keep
up
with
what
they
were
doing
at
the
speed
that
they
needed
it
and
that
the
consistency
that
they
needed
I
mean
this
was
pretty
important
stuff.
It
is
not
easy
to
get
two
photons
to
collide
with
each
other,
and
when
you
do,
you
want
to
keep
that
data,
so
that
was
what
they
did.
There's
a
great
paper
on
this.
A
If
you
ever
wanted
to
find
more
about
PBS
how
they
built
it
all
the
things
that
it
does,
but
it
shows
you
like
this
is
a
scale
problem
right,
and
this
is
an
emphasis
on
an
e-commerce
fabric,
application
which
I
think
is
kind
of
cool.
It's
not
you
know
another
website.
This
is
particle
physics,
doing
particle
physics
and
having
that
data
stored
at
Cassander
database,
that's
all
time
series.
Let's
talk
about
that.
So
I'd
say
you
could
stand
up
for
a
time
series
you're
going
to
no
little
prize
right,
all
right,
maybe
not
okay.
A
So
why
are
we
going
to
use
time
Kassandra?
So
what
is
it
work
so
well?
Well,
they
tabled
that
BigTable
dare
model
that
I
talked
about
earlier
is
perfect,
so
the
big
table
data
model
is
hey,
I,
have
a
row
key
and
lots
of
columns,
so
that
creates
this
sequential
event.
That
makes
it
very
useful
for
the
slicing
of
data.
So,
for
instance,
when
you
have
a
row
key
and
lots
of
columns
you,
if
you
order
the
columns
correctly
and
that's
how
it
gets
laid
out
on
disk,
it's
very
efficient.
That's
really
key!
A
When
that
dean
is
on
the
disk
and
you
ask
for
it.
You
want
to
make
one
seek,
because
the
seek
is
a
costly
event.
That's
three
five
ten
milliseconds
of
seat
time.
Sometimes,
and
then
you
don't
want
to
lift
that
disk
it
off.
You
want
to
read
all
the
data
you
can
in
one
single
pass.
That's
what
we're
doing
here.
We
have
the
single
layout
of
data
in
a
single
row.
That's
a
very
important
thing
to
keep
in
mind
when
you're
doing
a
lot
of
slicing
of
data
like
in
time
series.
This
is
an
example.
A
We
have
a
weather
station,
it's
storing
temperature
data
and
that
temperature
data
is
being
collected,
say
every
what
every
day
we're
collecting
it.
So
this
was
really
bad
the
time
it
off
so
I
had
10
a.m.
10
a.m.
it
should
be
like
10
and
11
and
12.
But
anyway
the
the
weather
station
ID
is
going
to
be
a
unique,
unique
number.
So
each
weather
station
will
have
a
row
of
data
and
each
time
I
collect
a
temperature
reading.
I
create
a
new
timestamp.
A
Well,
I
create
some
time
stamps
in
order
from
left
to
right
now,
I
have
this
nice,
even
sequential
measurement
of
every
time,
I
collect
and
because
of
how
Cassandra
stores
data
the
column.
The
number
of
columns
is
not
very
it's
not
finite.
It
can
grow
further
out
if
I
only
have
a
little
bit
of
data.
I
can
only
need
a
few
columns
if
I
need
to
store
a.
B
A
Of
data
lot
of
columns
so
that
variable
amount
of
columns
is
very
critical
for
like
time
series
data
because
I
don't
know
how
many
I'm
going
to
have
so
what
I'm
going
to
do
now
whenever
I
go
to
get
that
data
and
I
think
this
is
where
this
is
where
the
speed
comes
from.
Is
that
I'm
going
to
get
locality
with
the
weather
station
ID?
So
let's
go
back
to
our
how
this
data
is
stored
in
the
Cassandra,
each
node
is
responsible
for
a
token
range.
A
My
weather
station
ID
100
right
well
that
gets
hashed
by
md5,
let's
assign
the
token
number
and
then
so
I
find
which
node
it
belongs
to
great
that
belongs
to
node
number
2.
So
whenever
I
say
give
me
data
for
a
weather
station,
ID
100,
it
hashes
it.
Ok
I've
got
to
go
to
web
to
node
number
2
for
the
dates
now
I'm
at
a
single
server.
Now,
once
I'm
at
a
single
server,
I
say
now,
I
want
to
start
with
date
of
10
9
at
10
a.m.
well.
A
That
means
I'd
take
an
index
week
right
to
that
data
and
I
want
to
grab
that
particular
piece
of
data.
Now
what
if
I
want
to
grab
a
range
of
data?
This
is
where
it's
really
efficient.
Now,
if
I
want
to
grab
it
from
10:00
to
11:00,
8:11
o-18
now
what
I
can
do
is
make
a
single
seat
to
the
disk
and
read
from
left
to
right.
It's
a
single
pass
on
the
disk
very
fast
and
that's
the
efficiency
angle
for
time
series
data!
That's
why
it's
like
this.
A
We
call
this
operation
of
slice
because
you're
not
doing
single,
seeks
and
random
seeks
on
the
disk.
If
you,
if
you
look
at
a
way,
storage
arrays
are
set
up
right
now,
like
large
Sam's,
that
work
with
something
like
a
Oracle
or
sequel
server.
Database
they're
built
around
this
idea
of
eye
ops
because
those
are
are
tons
and
tons
of
random
leads
on
your
database
with
Cassandra.
A
A
So
when
we
create
this
data
model,
we
create
this
very
easy.
This
temperature
table
and
we
create
this
weather
station
ideas-
is
one
of
the
fields,
the
event
time
and
the
temperature.
That's
it
so
now,
when
we
have
this
weather
station
ID
in
event,
time
is
a
primary
key.
What
I'm
saying
is
that
the
the
uniqueness
of
each
one
of
those
rows
we
create,
which
is
actually
a
column
teach
column
in
the
storage
engine,
will
be
the
Wednesday
shinai
D,
along
with
the
time.
A
So
whatever
I
asked
for
that,
when
I
put
that
data
in
I
say
insert
into
your
temperature
table
and
here's
all
my
data
now
when
I
go
to
query,
it
I
say
select
temperature
from
the
temperature
table
where
the
weather
station
idea
is
some
ID
and
then
I
take
a
slice
of
data.
I
need,
say
four
minutes
of
data
here
and
so
I'm
going
to
get
four
minutes
of
data.
From
that
query
perfect
and
that's
a
very
fast
query.
A
What-
and
this
is
where
we
get
into,
is
what
if
I
my
weather
station
ID
is
great,
but
then
I
I'm,
collecting
data,
say
every
second.
Now,
as
I
mentioned,
you
can
have
up
to
two
million
columns
in
Cassandra
or
it's
like
two
billion
rows
and
columns
or
columns
yes,
partitions
in
Cassandra.
Two
billion
is
a
big
number,
but
if
you're
doing
it,
every
second
you're
going
to
run
out-
and
that's
that's
a
limit
that
you
can't
deal
with
so
what
we
do
is
we
reduce
our
tricks
here
with
your
data
and
that's
a
partitioning.
A
The
partitioning
is
this
is
a
particularly
common
technique
of
doing
data
is
adding
something
into
the
row
key
so
that
you
create
a
different
type
of
locality,
so
weather
station
ID
combined
with
the
date
just
add
a
part
of
that
date
will
get
you
so
it'll,
be
all
the
weather
or
data
for
that
one
day.
So
every
second
in
that
day,
and
so
when
I
go
to
ask
for
that
data.
A
Now,
when
we
set
that
data
we're
going
to
be
adding
the
date,
so
you
can
see
here,
I
added
I
took
the
date
portion
out
of
the
time
stamp
and
I
made
it.
That's
the
primary
key
for
the
the
row
and
then
now
when
I
go
to
query
it
I
still,
just
all
I
have
to
do
with
acid,
not
only
the
weather
station
I
need,
but
the
date
that
I'm
looking
for
and
then
do
a
slice
on
my
time.
That's
perfect!
A
That's
going
to
be
very
efficient
to
use
and
probably
matches
what
I
was
trying
to
do
in
my
application.
Firstly,
so
tons
of
use
cases
for
time
series
logging,
data,
Internet
of
Things
boy,
plenty
of
those
going
on
right
now,
sensor
data,
like
temperature,
user
activity,
tracking
I,
have
a
talk
on
this.
Actually,
it's
about
you
know
when
people
are
using
your
website
or
using
your
mobile
application,
you
want
to
track
the
interactions
that
they
had
with
your
website
at
time.
A
Series
date,
another
one
that
is
being
used
quite
a
bit
in
financial
services
is
fraud,
detection
things
that
happen
over
time.
There
are
certain
things
that
don't
shouldn't
happen
in
a
short
period
of
time
like,
for
instance,
if
a
credit
card
number
is
used
in
two
places
in
a
very
short
amount
of
time.
That's
a
potential
fraud.
A
This
is
time
series
data,
Financial
Services
is
using
a
lot
of
Cassandra
right
now
because
it
keeps
track
it
keeps
up
with
that
speed,
but
it
also
distributes
really
well,
and
so
it
doesn't
go
down
and,
of
course,
our
new
favorite
use
case
is
to
get
a
Nobel
Prize.
If
you
want
to
know
they'll
prize
I
think
it
might
be
a
good
start
to
use
Cassandra
key,
it's
actually
free,
you
can
download
it
right
now,
but
and
if
you
get
a
Nobel
Prize,
you
can
thank
me
later.
A
So,
let's
talk
about
some
application
stuff
here,
like
big
big
picture.
The
big
picture
here
that
I'm
looking
at
it
I'm
building
an
application
that
I
want
to
be
online.
All
the
time
now,
I
have
part
of
it
in
the
United
States
part
of
it
in
Europe
and
I
need
to
be
active.
Active
active,
active
is
a
hard
thing
to
do.
A
I
spent
years
trying
to
make
that
work
as
an
architect
and
using
really
exotic
things
like
Golden
Gate
from
a
from
Oracle
or
some
crazy
I
was
trying
to
do
with
my
sequel,
trying
to
get
cross
replication
using
on
the
query
engine
in
it.
There's
just
it's
really
difficult
to
do
and
who
the
first
thing
you
have
to
manage
is
your
data.
The
data
needs
to
be
replicated
properly.
Most
other
thing
else
doesn't
eat.
You
look
at
your
bed
back
that
we
were
living
in
defending
individual.
A
The
data
itself
needs
to
be
replicated
and
that's
because
active
active
requires
that
nice,
through,
like
a
common
set
of
data.
So
here's
my
here's,
my
application
I
have
a
some
sort
of
web
apps
or
mobile.
App
and
I
have
European
customer
that
US
customer.
So
in
this
case,
what
I've
done
is
I've
created
the
situation
where
I
have.
A
Now,
if
there
was
something
happen
say
with
one
node
in
each
data
center
still
online
no
trouble
at
all,
because
hey
I
got
to
move
a
server
or
I
got
to
do
a
reboot,
because
we
security
no
problem.
So
that's
got
some
manageable
events.
You
should
be
able
to
take
a
single
node
offline
in
any
datacenter
anytime.
You
want
and
your
application
still
be
online
easy
with
now.
A
What
happens
if
a
whole
data
center
goal
of
life
and
I've
witnessed
that
a
couple
of
times,
and
that
was
not
a
fun
event
with
if
I
had
a
tornado
in
a
data
center
in
Northern
Virginia,
a
tornado
in
Northern
Virginia
is
pretty
rare
event.
The
fact
that
it
hit
my
data
center
really
was
aware
of
it,
but
it
happened
and
it
took
out
the
18
t
data
center
in
Northern
Virginia,
let's
offline
for
a
while,
they
got
it
back
online
pretty
quickly,
but
it
was
offline.
A
A
Their
data
is
going
to
be
there
because
it's
been
replicating
the
entire
time,
the
time
that
it
takes
to
replicate
data
from
Cassandra,
Cassandra
node
from
one
side
to
the
other,
and
the
data
center
is
about
the
latency,
the
one
so
from
Europe
to
the
US
you're.
Looking
at
about
100
milliseconds,
and
so
it's
about
hundred
millisecond
lag
so
chances
are
you
didn't
lose
any
data
or
very
much
at
all,
but
if
I
can
route,
I
can
sail
out
and
route
those
those
users
over
to
US
data
center.
A
The
users
are
pretty
unaware
of
this
happening,
and
this
is
actually
something
that's
done.
All
the
time
yeah
who
does
as
Google,
dosas
Facebook
good
I
mean
large-scale
internet
properties.
Do
this
they'll
fail
you
out
of
an
entire
data
center
and
you
will
have
no
idea
because
the
data
layer
is
being
managed
and
that's
really,
the
key
to
active
active
is
managing
the
data
layer.
Now,
whenever
I
get
Europe
back
online
will
tell
you
the
power
of
it.
Something
like
that
everything
goes
back
online
I.
Do
some
checks
make
sure
it's
ready
to
go
great?
A
The
data
that
was
in
the
US
is
now
replicating
back
to
the
Europe
becomes
consistent.
I
failed
back
on
my
European
customers,
they're
completely
unaware
they're
like
wow.
This
is
a
great
website.
Spit
online
forever
never
goes
down.
No
fails,
that's
what
we
want.
We
want
the
magic
magically
users
have
no
awareness
of
what's
going
on,
that's
great
and
we
don't
have
to
run
around
like
crazy.
A
So
let's
talk
about
some
of
the
users
who's
doing
this
at
a
large
scale-
and
this
is
this
is
just
a
this-
is
where
I'm
going
to
wrap
up
and
then
we're
going
to
do
some
Q&A
here,
but
I
wanted
to
show
you
what
other
people
are
doing.
Large-Scale
users,
not
very
small
and
unfortunately,
and
I-
have
a
small
bit
that'll.
Give
you
an
idea.
What's
going
on
the
easy
one
is
Netflix
they've
been
a
Cassandra
advocate
for
a
long
time,
but.
A
Yeah
and
you
probably,
if
you
learned
everything
about
Cassandra,
you
probably
heard
something
from
Netflix
along
the
way
and
reason
is,
is
because
they've
made
an
early
decision
to
completely
make
a
transition
from
their
Oracle
database
system
to
Cassandra
and
Cassandra
is
the
database
that
they
run
all
their
stuff
on.
They
have
it's
an
18
billion
dollar
company
and
they
rely
on
Cassandra.
That's
pretty
impressive.
That
means
all
user
accounts
playlists
the
payment
statistics
that
are
being
gathered
all
happen
inside
Cassandra.
A
So
one
of
the
things
I
like
to
point
out
about
Netflix
is
they
do
some
really
cool
things
on
the
operation
side?
To
now
add
this
in
that
picture
the
definian
army
here
the
finian
army
is
that
is
a
group
of
services
that
the
chaos
monkey
is
one
of
them.
It's
a
smokey
Azad.
We
have
this
whole
army
of
monkeys.
It
actually
are
just
web
services
that
go
around
and
do
things
now.
A
A
chaos
monkeys
job
is
to
randomly
shuttle
services
inside
production
data
production
services,
so,
for
instance,
it'll
shut
down
web
services
inside
of
Amazon
or
shut
down
a
Cassandra,
node
or
shutdown
would
create
like
latency.
In
between
two
different
services
whatever-
and
this
was
all
done
during
the
day
in
production-
now
that's
one
of
the
reasons
they
use
Cassandra,
because
if
the
chaos
monkey
shuts
down
one
of
their
servers,
it
doesn't
bring
down
Netflix
and
it's
how
they
design
their
entire
system.
A
The
database
matches
that
their
application
architecture
has
said
we
will
be
able
to
tolerate
a
lot
of
failure,
and
not
only
are
we
going
to
be
able
to
tolerate
it,
we're
going
to
do
it
on
purpose
all
day
long
and
they
do
and
that's
what
stays
online.
It's
just
a
great
opportunity
to
make
that
things
just
solve
it
and
their
programmers.
The
people
who
do
all
the
development
understand
that
hey
I
put
this
into
production.
It
could
go
off
on
it,
anything
what
am
I
going
to
do
and
Cassandra's
a
big
part
enough.
B
A
Way
different
use
case
and
Spotify
their
company
in
Sweden
and
mm-hmm
yeah,
they're,
really
big
in
Europe.
So
what
they're
kind
of
getting
that
way
in
the
u.s.
shows
in
India?
There
are
a
lot
of
places,
but
they're
I,
think
they're
rolling
out
globally.
Slowly,
but
million
is
on
a
lot
to
use.
It
really
uses
they're
storing
over
a
billion
playlists
for
this
song.
A
Good
new
excuse
cases
from
using
caps
and
over
fusion
I
hope,
you're
interested
I
put
a
link
in
here.
Yes,
I
will
be
sharing
these
slides
I'll
put
them
up
on
SlideShare
when
I'm
done
now,
I'll
put
them
in
the
median
group.
I'll
put
it
up,
put
the
slides
up
in
the
meetup
group
and
I'll
also
put
my
data
model
and
talk
link
in
the
meetup
group
links
as
well.
So
you
guys
can
have
some
resources
after
this
so
I.
A
My
new
favorite
is
Facebook
is
once
again
a
Cassandra
user
and
we
we
are
really
big
in
Instagram
Instagram,
of
course,
of
the
photo
sharing
lots
of
photos
up
there
and
it's
all
running
and
Amazon.
They
do
all
their
security
audits,
meaning
like
company,
making
sure
that
people
are
uploading,
the
wrong
data
or
something
like
that,
so
that
that's
being
run
through
Cassandra
their
newsfeed.
So
every
time
someone
looks
to
see
if
their
friends
put
pictures
up,
that's
all
being
served
out
of
a
standard
cluster.
A
So
we
have
we're
seeing
twenty
thousand
rights
per
second
and
fifteen
thousand
tweets
per
second
all
day.
Long
connect
cluster,
very
high
scale,
big
user
and
I.
Think
it's
only
like
30
nose
or
something
like
that
in
that
cluster
or
25
nose.
It
replaced
a
lot
of
their
posters
databases,
which
was
what
they
wanted
to
do.
They
wanted
to
get
away
from
a
single
point
of
failure
like
that
and
they
distributed
the
mode
and
it
works
really
good
Nana's
on
for
just
that
reason.
A
A
We
have
data
stacks
Academy
for
Apache
Cassandra.
We
have
free
training
available.
So
that
means
that
you
have
the
ability
to
go
out
there
and
get
crew
training
in
Java
writing
Java
code
against
Cassandra
database.
It's
a
online
learning
model.
Therefore,
the
first
floor
sessions
are
available
right
now,
I
have
a
friend
right
now,
who's
going
through
them
and
she's
she's,
really
learning
a
lot
she's,
pretty
impressive,
with
I
am
too
I.
Think
it's
great
there's
videos!
There's
diagrams!
There's
homework!
There's
tests!
A
You
will
learn
a
lot
about
program
and
Cassandra
in
this,
including
data
modeling.
So-
and
this
is
absolutely
free
one
percent-
and
when
we're
done
we'll
be
finishing
up
the
sessions
here
at
the
end
of
the
month,
I
could
actually
mix
month.
You
will
be
given
the
opportunity
to
be
to
take
the
certification
exam
to
be
a
certified
Cassandra
developer,
so
I
think
that's
one
sub.
A
This
is
something
you
should
think
about
doing
if
you're,
if
you're
a
developer,
even
an
architect-
and
you
want
to
learn
more
about
program
at
Cassandra,
this
is
a
great
opportunity.
Go
do
it
right
now,
and
this
is
for
you.
We
want
to
have
a
hundred
thousand
registrations
by
the
end
of
2014
we're
on
our
way.
We've
got
a
lot
of
people
in
there
already,
but
we
also
along
that.
We
want
to
have
25,000
certification.
So
maybe
you.
B
A
B
A
The
standard
store
all
the
indexes
that
memory
or
can
be
configured
partly
on
disk
or
partly
in
memory.
Well,
the
indexes
there
are
indexes
in
memory
for
various
things,
so
the
indexing
extender
is
not
like
a
relational
database
index.
An
index
is
not
built
for
speed
in
most
cases.
So
it's
more
of
a
convenient,
that's
a
secondary
index.
It
helps
you
find
data
in
columns
now
Kassandra
itself
in
the
storage
engine
indexes
the
rows.
A
So
if
you
have
a
really
wide
storage
row,
it
will
index
the
data
inside
that
storage
room
for
fast
access
in
there
and
that's
stored
in
memory
and
durably
on
disk
as
well
so
indexes
that
make
the
most
sense
for
you
in
that
case,
are
in
both
like
both
in
memory
and
on
disk,
the
indexes
you
can
create
our
only
own
disk
and
that's
I,
think
that's
a
big
difference
and
it's
a
distributed
joint.
So
it
has.
A
It
takes
a
long
way
to
run
when
you
go
into
data
model,
you
talk
a
lot
about
secondary
indexes
and
go
into
detail
of
how
they
work
or
why
they're
good
or
why
they
aren't
so
good.
That's
definitely
worth
watching
and
then
I
also
see
is
a
session
recording
gravy.
You
probably
have
access
to
more
of
these
and
I
do.
Yes,
we
are
recording
this
I'm,
not
sure.
If
we're
very
posting
it
Brady
Dino,
you
can
unmute
yourself
buddy.
B
A
B
B
A
The
best
for
three
and
Buster
he
after
roughly
three
got
to
knit
down
yeah
if
that
that
blue
move
her
to
predict
order
rebuilding
the
day
and
I
wanna
be
exact
little
over
there
to
get
pages
of
problems
so
Lance
part.
So
in.
If
you
have
a
large
cluster,
let's
say
you
had
a
hundred
nodes
and
you
lost
two
nodes:
the
chances
of
you
having
a
problem
is
pretty
slim.
A
If
you
have
a
four
node
clustering,
you
lose
then
that's
half
of
your
half
your
nodes
are
offline,
then
that
is
a
problem
something
to
plan
for.
So,
if
you
do
have
that
problem,
then
you
can.
You
know
I
mean
this.
Is
the
you're
just
going
to
shut
down
your
reach
for
dead,
but
they're,
not
something
we
need
to
plan
for,
if
you
think
you're
going
to
have
that
many
or
you
can
have
that
bit
of
a
problem.
We've
talked
about
how
you
plan
your
cluster,
that's
where
it
comes
from.
A
Let's
see
so
community
edition.
Of
course,
it's
absolutely
free
free
of
cost
commercial
purposes.
Whatever
you
want
Cassandra
Apache
Cassandra,
which
is
the
community
edition,
there's
no
difference
between
the
Community
Edition
that
we
offer
on
our
website
and
what's
on
the
Apache
website,
the
only
reason
Community
Edition
is
exists.
Right
now
is
we
have
we're
doing
that
as
a
that?
We
package
it
well,
we
create
debian
and
RPM
package
files,
so
you
can
use
it
as
much
as
you
want.
A
It
is
open
source
software
free
as
in
beer,
go
for
it
have
fun
if
you
ever
need
help
or
support
that's
what
data
facts
is
here,
for
we
don't
own
Cassandra,
but
you
can
have
it
all.
You
want
good
choice
for
computing
column,
values
such
as
multiply,
add
now,
Cassandra
doesn't
have
built-in
aggregation
functions;
it
won't
do
some
nations
and
that
sort
of
thing
computing.
Those
column
values,
is
something
that
you
would
do
outside
now.
B
A
In
cases
where
we're
multiplying
and
adding
many
people
use
some
sort
of
pre-processing
as
their
is
consuming
the
data
such
as
storm
to
pre
aggregate
those
values,
not
so
that's
a
very
common
way
of
getting
staff
data,
so
if
you
have
real-time
analytics
needs
more
than
likely,
you
should
be
pre
computing.
Those
those
as
you
get
the
data
and
Cassandra
is
a
great
database
to
store
behind
that.
A
If
you
query
a
secondary
index
column
and
get
a
time
out,
it
could
be
that
you're
querying
a
very
something
with
really
high
cardinality
again,
you
should
probably,
if
you
want
to
hit
us
up
on
on
the
on
stackoverflow
or
something
like
that,
would
be
exactly
what
your
data
model
is
secondary
index.
Let
me
point
this
out:
those
secondary
indexes
are
not
for
speed.
They
are
perfect
convenience
if
you're
doing
a
lot
of
secondary
indexes.
I
would
really
ask
that
you
look
at
our
data
modeling
discussions
and
some
of
my
videos
about
that.
A
A
So
is,
if
you
know,
change
of
Cassandra
code
only
is
a
big
data
solution.
Now
you
don't
have
to
have
a
lot
of
data.
Actually,
this
is
interesting
about
Cassandra's.
We
talked
about
these
large
data.
You
know
terabytes
petabytes
of
data,
but
I
would
say
that
I've
seen
more
like
I
was
working
with
the
team
at
a
retailer
they
have.
Their
total
database
was
about
a
hundred
gigs
of
data,
not
very
big,
not
very
big
at
all,
but
what
they
needed
to
do
is
have
maximum
time
in
Ramat
and
scalability.
A
So
they
have
this
100
gigs.
The
data
spread
out
over
two
data
centers
over
24
nodes,
and
so
we
had
not
a
lot
of
data.
I
mean
what
you
would
consider
a,
not
so
big
data,
but
they
just
had
a
different
requirement.
They
needed
to
replicate
their
data,
have
good
replication
and
they
needed
to
have
that
scalability
they
fake
it
that
they
could
have
some
reliability
with
all
right.
So
the
best
programming
language.
A
Java
versus
Python
well,
of
course,
Java
is
going
to
be
faster
than
Python
and
I
mean
that's
just
a
way
that
it
works.
If
you're,
if
you're
doing
a
lot
of
calculations,
probably
Java
is
where
I
would
land
if
you're
trying
to
do
rapid
application
or
that's
not
as
much
of
an
issue,
your
pre-calculated,
your
data
in
cassandra
Python,
would
be
a
good
choice.
Fuzzing
match
component
plan
for
the
future
when
you
need
to
do
this
is
where
data
sex
Enterprise
comes
in
fuzzy
matches
is
pretty
much.
A
What's
so
learned
about
and
dat
effects
enterprise
which
you
can
also
download
for
free,
it's
not
free
for
production,
but
you
can
use
it
right
now.
Davis
X
Enterprise
integrates
solar
with
Cassandra,
so
it's
you
will
create
solar
indexes
on
top
of
your
column
down,
so
you
can
do.
Fuzzy
matches
boosts
that
sort
of
thing
ready
to
regular
expression,
type.
One
look
up
and
I
see:
we've
got
some
other
questions
in
the
other
window.
A
Is
going
to
pretty
much
be
on
any
performance
metrics,
especially
at
large
scale,
the
difference
I
think
the
biggest
difference
is
in
what
in
your
data
model
is
looking
at.
So
Margot
is
a
document
database.
Cassandra,
of
course,
is
column,
family
and
you
know
rows
and
columns,
and
that's
that's
what
it
is.
If
you're
looking
for
a
document
database
is
a
great
choice,
that's
that's
what
it's
built
to
do.
The
scaling
is
different.
There's
some
great
discussions
or
there's
some
great
articles.
A
Companies
that
have
moved
from
to
Cassandra,
just
because
of
their
scaling
problems
is
a
synchronous,
replication
system,
so
it
uses
shards.
So
there's
a
master/slave
architecture
and
there's
global
locking
and
a
few
other
things
once
you
get
to
a
certain
size
that
just
doesn't
keep
up.
You
know:
I
work
constantly
continuously
with
look
Gayle
clusters,
I
mean
you
can
scale
it.
You
can
have
just
three
nodes
in
your
cluster
or
you
could
have
a
thousand
I
work
with
a
lot
of
customers.
I
have
a
thousand
own
clusters.
A
It
scales
pretty
well
in
that
way,
so
your
read
performance
is
just
about
adding
more
notes
that
cave.
So,
let's
see,
what's
the
major
difference
between
Cassander,
couch
and
okay,
again
is
document
database,
its
main
based
on
master
slave
architecture
couch
is
a
consistent
hash
system,
but
it's
also
a
document
database.
A
Both
Mangala
and
couch,
have
no
replication
over
the
LAN
or
one
that
works
very
well.
Couches
and
Couchbase
has
the
ability
to
do
it
that
it's
based
on
a
synchronous,
transfer
and
cassandra
is
more
built
in
the
router
direction
because
of
the
dynamo
couch
and
are
both
based
on
different
types
of
technology
or
cause
sanded.
Based
on
diagonal.
A
This
Cassander
used
raid
for
data
replication
know
the
data
replications
built
into
cassandra.
As
a
matter
of
fact,
we
even
have
a
mode
where
you
can
use
J
Dodd,
and
you
know
just
a
bunch
of
disks
for
your
data
on
disk.
We
don't
require
raid
on
the
server,
because,
if
you're
replicating
your
data
properly
across
different
nodes,
it's
not
going
to
be
as
much
of
a
problem.
If
you
lose
an
entire
server,
your
data
is
still
safe
because
it
is
on
a
different
one.
Let's
see
any
more
questions
here.
A
A
Where
cuz,
there
are
many
big
data
focus
where,
where
cassandra
will
fit
Sanders
well,
Cassandra
is
an
application
to
persistence
database.
So
if
you're
building
applications
with
the
kind
of
requirements
that
I
showed
I
think
from
a
transaction
database
Cassander
the
grape
fit,
you
should
at
least
take
a
look
at
it
because
it
matches
what
you're
trying
to
do
with
an
application.
It
is
not
an
analytics
database.
It's
not
like
something
like
a
it
does
not
keep
it's
not
the
same
thing
as
a
Hadoop.
A
Hadoop
would
be
a
different
type,
I
mean
Hadoop
is
a
batch
or
an
analytics
database.
We're
not
analytics
we're
about
transaction.
Most
times
we
see
people
looking
at
their
my
sequel,
Oracle
versus
Cassandra.
That's
we
play
in
that
field
because
they're
trying
to
get
their
application
in
a
state
where
they
can
move
fast.
A
What's
the
difference,
trink
of
standard
and
Redis,
very
different
technologies,
Cassandra
and
reddit's
fit
in
different
niches.
Actually,
we
know
people
that
use
Cassandra
and
Redis.
At
the
same
time,
Redis
is
an
in-memory
database,
which
means
has
very
limited
replication.
Redis
has
some
really
cool.
In-Memory
analytics
features
that
people
really
like,
but
it
is
very
single
point.
Cassandra
is
more
for
larger
data
sets
or
ones
that
need
to
be
replicated
better
or
where
you
need
a
richer
data
model.
Of
course,
Redis
is
a
key
value.
A
A
It's
more
of
a
utility
to
do
database
where
you're,
storing
calendars
and
things
like
that,
you'll,
see
and
well
in
Redis
is
always
going
to
be
faster
in
a
lot
of
calculations
because
it
just
it's
all
in
memory,
cassandra
is
going
to
be
faster
for
some
things
like
slicing
of
data,
large-scale
data
pools
that
sort
of
thing
or
even
when
you
get
into
larger
scales
of
data,
how
much
data
you
have
but
registers
is
an
in-memory
database.
It's
going
to
be
fast,
green,
green,
plum,
aquariums,
linear,
scalability!
Oh
that's,
cute!
A
Well,
green
plum,
of
course,
is
the
egg
columnar
database.
So
it's
not
really
a
comparable,
yeah
I
know
greenplum
likes
to
make
that
claim,
but
they
don't
have
that
kind
of
claim,
because
there's
a
replication
story
is
pretty
weak
and
cassandra
is
going
to
beat
them
every
day
a
week
and
glen
download
greenplum,
try
it
out.
You're
not
going
to
be
able
to.
It
is
very
complicated,
so
I
like
I
like
to
think
that
it's
nice
that
they
want
to
be
our
competitor,
but
Cassandra
is
just
a
different
type
of
database.
A
It's
not
a
new
Hadoop
all
right,
so
we're
not
able
to
query
partition.
Columns
using
page
from
sequel,
storage,
I
think
I.
Think
that's
one!
That's
coming!
You
might
want
to
try.
What's
what's
in
there
right
now
in
Boyde,
at
effects.
Enterprise
I'm,
not
as
familiar
with
the
pig
stuff
but
I,
know,
there's
a
lot
of
stuff
coming
data
sex,
Enterprise!
Sorry,
don't
have
a
really
good
answer
there,
but
I
know
that's
one
of
the
things
that
in
pig
did
you
get
fixed
a
solution
like
Impala
at
data
stacks?
A
Well,
you
can
actually
run
Impala
on
topics
and
ER.
If
you
want
to
do,
we
have
somebody.
Try
that
it
does
work.
Impala
is
a
is
more
or
less
a
an
analytic
style
database.
We're
not
really
excited
about
Impala
at
all.
It
is
not
a
very
thought-out,
well
thought-out
technology,
and
it
is
very
complicated
and
it
has
a
lot
of
failure.
Points
I,
think
that
we
should
check
out
is
what
some
people
are
in
the
Cassandra
community.
A
Not
a
data
stacks
but
in
the
community
are
doing
with
shark
and
spark
the
performance
and
simplicity
of
it
are
way
better
than
Impala,
and
it's
very
interesting
to
look
at
come.
You
can
Google,
Cassandra
and
shark
or
Cassandra
and
spark
and
there's
a
couple
of
talks
out
there.
What
people
are
doing
with
it,
and
it's
really
fast.
It's
amazing
and
Cassandra
is
really
good
for
that,
because
it
spreads
the
data
around
when
we
talk
about
transactions.
The
high
integrity.
A
Well,
first
of
all,
transactions
are
quality
that,
like
an
acid
transaction,
you
will
never
get
with
defender,
because
PASOK
requires
a
single
database.
You
can't,
even
though,
how
some
people
say
you
can
you
can't
really
do
that
over
multiple
databases
without
an
enormous
amount
of
locking,
but
even
then
you're
going
to
have
a
problem,
so
Cassandra
is
not
ask
complain,
it
is
cap,
consistency,
availability
partition
and
so
what?
What
do
we
do
to
maintain
the
highest
integrity?
A
Well,
the
consistency
level
is
one
thing:
when
you
set
data
in
your
database,
you
say:
I
want
all
replicas
when
you
set
it
to
all
you
get
all
replicas.
We
also
have
a
transit.
What
we
call
lightly
transaction,
which
guarantee
single
source
single
semantics
on
an
update
or
insert,
and
that
is
LD
bTW,
that's
in
Cassandra
2.0
and
that
uses
taxes.
So
the
Paxos
underneath
is
what
maintains
that
coordination
between
all
the
nodes
that
are
participating
and
it
gives
you
that
transactional
guarantee
them
for
the
highest
integrity.
A
I
have
a
talk,
I'm
going
to
be
doing
a
webinar
next
Thursday
we've
got
a
chance
to
do
that
and
I
will
be
talking
about
lightweight
transactions,
so
go
to
client
Cassandra
sign
up
for
my
webinar
next
Thursday
I'll
be
talking
about
those
transactions,
so
there's
another
transaction
management
movie
in
comes
Andrew
again.
Thursday
I'll
be
talking
about
that.
It's
called
lightly
transactions.
It's
really
I'll
be
going
in-depth
in
there.
But,
yes,
there
is
a
transaction
management
in
there.
A
It's
not
a
commit
wrong
back
now,
but
it
is
will
keep
your
data
consistent
in
the
way
that
like,
if
you
have
multiple
writers
and
multiple
readers,
is
it
a
good
choice
for
big
relational
data
model?
That's
kind
of
a
loaded
question:
it's
not
a
relational
database,
but
is
it
a
good
choice
for
that
type
of
data
model,
not
the
model,
but
the
data?
The
data
that
you
store
in
a
relationship
can
be
denormalized
almost
every
time
I
mean
when
we
create
normal
forms
of
data
and
I
did
this
for
years.
A
It's
about
breaking
your
data
into
representative
tables.
So
what
I?
What
I
see
is
that
whenever
you
create
a
data
model
or
you
do
data
modeling,
relational
verses,
Cassandra
with
relational
databases,
you
start
with
your
data,
you
build
your
models
and
then
you
write
your
application
based
on
the
models
with
Cassandra.
You
start
with
your
application.
You
build
your
model
based
around
the
application,
and
then
you
store
your
data
that
turns
it
on
its
head.
A
But
if
you
look
at
what
relational
data
is
it's
just
another
form
of
your
data,
and
so
sometimes
when
you're
writing
your
application.
It's
exactly
in
data
just
in
a
different
form,
so
denormalize
and
data
say
from
a
big
like
a
huge
relational
database,
isn't
crazy
at
all.
What
you
have
to
be
ready
for
those
would
be
normalization
comes
duplication.
You
may
have
more
than
one
copy
of
that
data
in
different
tables,
not
fun,
because
you're
actually
making
it
optimized
for
your
application
itself.
So
that's
one
of
the
things
that
we
really
stress
not
again.
A
A
These
are
way
more
rights,
we're
getting
into
like
some
specifics
here.
So
again
the
ordering
is
important
whenever
you
do
any
kind
of
where
clause
for
the
parts
of
the
partition
key.
You
have
to
do
them
in
order,
so
you
can,
if
you
try
to
do
it
on
a
when
you
have
a
and
B
combined
your,
not
that
a
and
B
always
have
to
be
together,
you're
saying
no
they're
unique.
Those
always
have
to
be
queried
together,
because
when
you
look
at
what's
stored,
that's
the
locality
of
the
data.
A
A
Going
back
to
my
weather
data
model,
I'm,
saying
I'm,
with
my
weather
station
ID
and
my
date,
I'm
going
to
combine
those
together
so
and
only
an
equal
or
in
for
partition
call,
and
that's
because
that
partition
column,
but
the
key
the
partition
key.
Then
primary
key
with
the
single
values
and
the
key
can
only
be
an
equal
or
in
because
you're
actually
you're
going
to
be
scanning
over
multiple
rows
of
data.
We
do
not
allow
row
scans
to
scan.
A
You
have
to
do
that
in
a
column
format,
which
means
that
you'll
have
to
do
that
in
the
in
the
partition
key
as
a
in
the
column
partition
keys,
which
are
the
secondary
parts
of
that.
So
yes,
when
you're
doing
a
filtering
on
index,
columns,
if
you
say
allow
filtering,
then
you're.
Basically
saying
I'll,
let
this
run
forever
and
that's
a
data
modelling
problem.
A
You
probably
have
modeled
your
data
in
a
way,
that's
inefficient
away,
Cassander
works
and
that
you
can
pivot
that
again,
I
would
say,
watch
my
data
modeling
talks
or
even
take
that
online
course
at
least
the
first
two.
The
first
two
courses
and
we
actually
talked
about
doing
filtering
filtering
is,
is
if
you
have
to
allow
filtering,
you're,
probably
going
to
get
a
very
slow
response
or
timeout
just
because
you're
doing
something
really
not
what
it's
wanting
to
do.
A
So
data
migration
data
migration
is
a
tricky
subject
because
I
don't
want
you
to
just
copy
a
relational
database
into
Cassandra.
I
do
want
you
to
think
about
your
data
and
what
you're
actually
doing
with
it.
That
being
said,
there
are
some
good
tools
like,
for
instance,
10
Tahoe
kettle,
which
is
an
open
source
tool,
does
really
good
ETL
it
there's
native
drivers
for
Cassandra
or
just
being
able
to
write
some
code
to
pull
the
data
out
of,
say,
an
Oracle
database
and
dump
it
into
your
Cassandra
database.
You
may
need
to
do
normalize.
A
You
may
need
to
pivot
some
of
the
data,
so
sometimes
that's
the
way
it
works.
All
right,
Sophie
is
the
in
clause
in
index
column
and
the
where
clause.
The
n
is
only
for
the
first
part
of
the
primary
key.
That's
because
what
you're
looking
at
is
storage,
rows,
you're,
looking
what
you're
doing
is
you're
mulling,
multiple
rows
of
data
and
that's
how
that's
how
the
in
works.
So
again,
it's
really
kind
of
in
what's
happening
underneath
the
covers
so
there's
Cassandra
for
secondary
it
reports,
support
secondary
indexes
and
the
secondary,
but
not
secondary,
keys.
A
I
think
I
got
that
right.
Secondary
indexes
are
supported
and
again
are
not
named
for
speed,
but
for
efficiency
itself.
I
got
a
couple
more
questions
up
here
and
then
we're
going
to
have
to
wrap
up
here
see
almost
no
idea
set
the
replication
factor
to
two
and
later
I
changes
your
replication
factor
to
your
level
pair.
What
is
it
both
stated
check
to
the
replication
factor
of
the
three
afternoons?
Literal
repair?
Well,
the
best
way.
To
knows
when,
then,
when
the
repair
is
finished,
you're
done
I
mean
it.
A
A
If
you
increase
the
replication
factor,
then
that
means
the
repair
process
is
what
can
move
that
data
allowed,
and
so
when
that
data
is
moved
around
inside
the
cluster
you're,
making
sure
that
everything
will
do
repair
processes
hey
this
one
node
needs
to
be
consistent
with
all
the
other
notes,
and
so,
if
you
run
a
repair
on
all
four
nodes
will
say
or
multiple
nodes,
then
you
should
every
node
will
then
be
consistent.
That
means
that
you
get
your
replication
factories
applied.
A
A
If
you
have
two
clusters
with
a
different
schema,
which
is
probably
tables
and
column
families
you
can,
if
you
want
to
bring
in
that
different
schema,
you
can
take
those
SF
tables
and
run
what's
called
a
bulk
loader,
and
the
book
lawyer
will
just
read
the
SS
cables
and
stream
them
directly
into
your
call
into
your
database.
There's
some
documentation
on
the
bulk
load
function
on
our
website.
Just
look
that
up
and
that's
actually
not
a
very
hard
thing
to
do
at
all.
A
What's
really
cool
about
SS
cables
is
because
they're
immutable,
they're
more
or
less
like
a
backup
degree
data,
and
so
you
can
move
those
SS
tables
around
a
week.
Free
easily
see
communiques
plain
how
to
stand
our
Hadoop
integration
works.
Okay,
so
two
things.
First
of
all,
there's
an
open-source
version,
so
they're
open
source
that
we
provide
on
the
copy
side.
There's
two
classes:
one
is
called
the
bulk
import
format
and
both
output
format
and
both
input
and
bulk
output
from
it.
A
Those
are
purpose-built
to
be
put
inside
MapReduce
code
and
they
basically
talk
to
a
Cassandra
database.
And
if
you
need
to
iterate
over
that-
and
you
can
use
that-
and
you
know
iterate
over
cast
and
makalah
families,
then
you
can
are
tables.
You
can
use
those
classes
inside
your
MapReduce
jobs.
Now,
if
using
data
sex
Enterprise,
we
provide
all
that
integration
for
you.
So
in
the
case
where
you
run
or
not,
you're
actually
projecting
the
the
hive
table
against
a
column
family
in
Cassandra.
A
A
It's
not
meant
to
be
aid,
a
new
version
of
Hadoop.
It's
really
to
run
an
analytic
type
workload
like
a
duplicate
on
Cassandra
I.
Had
another
question
up
here:
if
a
node
is
down
and
whites
are
saved
in
the
system
hands
table,
what,
if
a
read
request
comes
in
well,
if
your
fully
replicated
the
read
request
should
go
to
the
the
replicas,
so
you
should
still
be
covered
there.
The
hints
table
does
not
you
don't
serve
reads
out,
ends
table
the
hands
table,
just
stores
the
data
for
the
node,
that's
off
one
now.
A
B
A
Your
reads:
well,
since
all
three
replicas
are
not
online,
that
reads
going
to
fail:
it'll
say:
sorry,
all
those
all
the
replicas
are
offline
or
not
all
the
replicas
are
inline.
If
you
do
it
a
quorum,
then
it
will
satisfy
because
two
out
of
those
three
51%
are
online.
Now,
if
you
lose
two
methods-
and
this
is
go
back
to
an
era
previous
question,
if
you
lose
two
nodes
and
you
do
replicate
there-
you
do
a
consistency
level
quorum.
Then
you
will
get
a
failure
on
that,
because
now
it's
less
than
51%
online.
A
So
then
you
can
take
that
to
a
consistency
level
of
one
and
that
read
request
will
be
satisfied.
Not
that's
how
you
keep
you
can
use
consistency
levels
sometimes
to
maintain
the
highest
amount
of
time.
So
whenever
that
new,
when
that
node
comes
back
online,
that
system
hint
data
will
then
be
played
back
links
that
we
node
or
in
that
node
it
was
offline.
It
will
become
consistent
after
that.
So
then
every
read
after
that
will
then
go
to
that
node
as
well.
A
B
A
Right
I
think
we're
at
the
end
here.
I
will
I
will
be
posting
a
few
things.
I'll
put
some
links
out
there
on
the
on
the
meetup
websites
and
and
I
will
be
putting
some
links
on
Planet
Cassandra,
we'll
put
those
up
on
the
meetup
website,
so
everybody
should
have
the
content,
probably
the
next
few
days
here,
but
just
keep
an
eye
on
the
meetup
website
and
we'll
put
that
up
there.
A
Thank
you,
everybody
for
showing
up.
We
so
glad
we
do
this
next
time.
I
really
want
to
do
this
in
person.
I
got
to
make
it
to
India
I.
Think
I
tweeted
that
out
today
we
would
be
I
think
it's
a
good
time
to
have
a
road
trip.
So
hopefully
I'll
meet
everybody
in
person
someday
soon
next
year
we
got
a
lot
of
traveling
plans
and
I
would
love
to
meet
everybody
do
a
couple
of
sites.
So
thank
you
very
much
have
a
great
Saturday
and
we'll
talk
to
you
later.