►
Description
Speakers: Michaël Figuiere, Software Engineer at DataStax & Alex Popescu, Senior Product Manager at DataStax
Slides: http://www.slideshare.net/planetcassandra/c-summit-eu-2013-cassandra-made-simple-with-cql-drivers-and-devcenter
Is Cassandra too complex for newcomers? Besides the many improvements that have made their way into C* to dramatically simplify it and the finalized Cassandra Query Language, the SQL-like query language that should look familiar, new drivers have been created with a modern and efficient API. Last, but not least, DataStax is introducing *today* DevCenter 1.0, an IDE whose goal is to simplify developer's workflow even further and to improve their productivity. This presentation will show you how putting to work the new drivers and DevCenter can make your daily life with Cassandra nicer!
A
You
already
heard
the
trend
of
simplifying
things.
We're
working
with
cassandra
and
what
the
team
here
is
building
is
focused
on
simplifying
developers,
life
and
the
second
part
of
the
talk
will
be
about
the
datastax
drivers
and
the
core
principles,
and,
last
but
not
least,
we'll
surely
introduce
dev
center,
which
is
a
new
piece
of
tool
that
we
are
extremely
excited
about.
A
So
for
a
long
time,
if
you
are
in
the
business
of
software
development,
we
heard
this
use
the
right
tool
for
the
job,
and
I
think
us
as
professional
should
extend
this
question
to
use
the
best
tool
for
the
job
and
what
does
it
mean
to
us
when
creating
tools
for
developers?
What
does
it
mean
to
create
the
best
tool?
What
does
it
mean
to
create
the
simplest
tool?
A
So
basically,
what
we
have
in
mind
when
creating
these
developer
tools
is
to
simplify
choices.
We
have
too
many
choices
to
make.
They
are
rather
complicated.
We
should
focus
our
choices
on
the
most
important
aspects
of
our
application
and
not
spend
a
lot
of
time
on
picking
every
library
and
changing
libraries
and
so
on
and
so
forth.
B
Thank
you
alex
so
yeah.
Let's
have
a
quick
overview
about
all
these
new
secure
drivers
that
dastak
has
started
to
create
over
the
past
year
now,
but
first
of
all,
I'd
like
to
to
record
you
one
of
the
biggest
addition
to
to
customer
world
to
to
to
customer
database
in
this
process
of
simplification
on
simplifying
the
interface
that
you're
working
with
daily.
It's
definitely
to
us.
Cql
sql
was
definitely
the
step
one
in
order
to
make
things
easier.
B
Probably
those
guys
that
are
here
that
are
still
working
and
that
have
worked
in
the
past
with
the
swift
interface,
definitely
understand
what
I'm
talking
about
so
cql.
I
think
probably
most
of
you
guys
were
either
at
the
at
the
keynote
this
morning
or
the
state
of
cql
session
by
silva
earlier
this
morning
as
well.
It's
a
query,
language
sql-ish!
B
It's
it's
schema
full,
it's
no
more
schema
less!
So
you
structure
cleanly
all
your
all
your
data
and
it
comes
together
with
a
brand
new
protocol
with
what
we
call
a
cq,
the
cql
native
protocol
that
has
been
introduced
with
castle
1.2
and
this
protocol
come
as
a
replacement
for
swift.
It's
not
meant
to
push
swift
away
from
casanova.
Swift
will
remain
as
a
supported
interface
for
very
long,
but
this
protocol
is
what
we
needed
to
continue
to
move
forward
with
cq,
with
casanova
and
as
a
mature
database.
B
So
that's
with
all
the
drivers
that
we've
released
there's
some
things
that
we
wanted
to
do.
We
wanted
to
to
offer
a
consistent
interface
across
all
the
language,
as
well,
of
course,
as
across
all
the
tools
either
sql
sh
or
next
ulc,
with
dev
center,
so
that
developers
can
can
have
a
consistent,
waveform
so
constant
language
and
for
the
driver
we
wanted
to
have
exactly
the
same.
B
That
is
a
constant
set
of
features,
so
the
java
driver
is
is
based
on
an
asynchronous
interface,
but
that's
also
the
case
of
all
the
other
drivers
that
that
does
tax
has
developed
or
is
developing
right
now
or
will
develop.
Next.
We
support
reaper
statement.
We
support
failover
load,
balancing
in
different
kind
of
with
different
kind
of
way
to
finely
tune
the
way
you
you,
you
do
your
load
balancing
and
your
fade
over
and
this
way
of
tuning
things
will
come
with
us.
B
B
B
There
were
some
limitations,
and
this
is
probably
one
of
the
most
interesting
limitation
and
and
actually
of
the
new
features
that
we
introduce
with
this
protocol.
That's
request.
Pipelining,
request
pipelining,
as
as
you
can
see
on
this
diagram
is
simply
about
the
fact
that,
as
a
client
doesn't
wait
anymore
for
the
response
to
come
before
sending
the
next
request.
B
So,
whenever
the
the
answer,
the
response
will
come
back
to
it
to
him.
It
will
just
dispatch
it
to
the
suede
to
the
clients
where
they
is
waiting
for
the
answer
following
a
stream
id
following
a
kind
of
dispatching
id
that
is
attached
with
every
request
so
in.
In
other
words,
what
we
do
is
simply
that
we
multiplex
a
bunch
of
painting
requests
on
top
of
connection,
and
that
was
very
important
for
us
for
to
support
very
large
cluster,
where
the
amount
of
connection
created
on
customer
nodes
was
started.
B
So
I
want
to
make
it
clear
here:
we
are
absolutely
not
talking
about
a
notification
for
changes
in
your
data.
We
are
talking
only
about
purely
technical
notification
for
events
coming
from
casanova
events
happening
in
in
either
the
topology
of
the
cluster,
the
schema
that
you
use
in
your
cluster
or
whenever
you
add
a
node,
your
remove
node,
a
notification
will
be
sent
to
the
client,
so
the
client
doesn't
have
to
pull
the
cluster
all
the
time
to
get
all
this
information
and
that
dramatically
simplifies
their
design.
B
Actually,
so
here
the
kind
of
asynchronous
architectures
that
we've
got
is
that
you
will
have
a
bunch
of
client
suede.
You
know
that
can
typically
be
your
http,
the
suite
for
each
of
your
http
requests,
and
they
will
talk
with
the
drivers,
which
will
be
a
singleton,
and
this
driver
will
just
be
responsible
to
dispatch
your
request
to
to
the
appropriate
node.
According
to
the
load,
balancing
policy
that
you
selected
and
for
each
of
this
node,
we
will
maintain
a
pool
of
connections.
B
B
The
appropriate
connection
in
the
connection
pool
is
selected
as
well,
depending
on
how
much
pending
connection
we
add
on
each
of
the
how
much
pending
request
we
had
on
each
of
the
connections
and
whenever
the
response
comes
back,
it
will
be
dispatched
to
the
client
thread
that
was
waiting
for
it
so
in
practice,
because
that's
a
nice
architecture,
architecture
dragon.
But
let's
talk
about
some
code
and
I
will
use
the
java
driver
for
all
this
presentation.
B
It's
definitely
not
the
only
one.
As
a
reminder
we've
got
java
driver
we've
got
the
c-sharp
driver
which
are
both
final
and
production,
ready.
We've
got
python
driver
that
is
being
finalized
right
now,
and
we're
working
to
integrate
to
to
to
support
much
more
language
in
the
future,
but
well
java
is
still
the
most
popular
language
among
the
customer
users.
So
that's
probably
a
good
choice.
So
here
I
and
that's
the
beauty
of
of
this
new
apis
that
we
propose
to
you.
B
B
We've
tried
our
best
to
modernize
to
modernize
in
some
way
the
jdbc
interface,
as
we
provide
you
a
way
that
says
that
is
directly
iterable,
so
you
can
put
it
in
a
for
which
loop,
which
is
much
more
convenient
in
a
java
application,
so
probably
no
need
to
to
to
spend
more
time
on
this.
Actually,
it's
fairly
basic,
that's
probably
where
things
get
much
more
interesting,
especially
with
castlemore,
because
we
know
that
castle
noir
is
by
design
very
appropriate
for
very
large
scale
applications
and
in
large-scale
environments.
B
B
Basically,
you
will
be
able
to
execute
asking
to
get
a
future
on
your
wizard
set
and
and
and
waves
that
you
will
simply
be
able
from
a
single
suede
to
push
a
bunch
of
requests
in
parallel
and
then
to
simply
wait
on
all
of
these
features
to
to
to
get
the
results
if
you're
not
familiar
with
the
future
architecture
of
java.
I
strongly
advise
you
to
have
a
look
at
it.
It's
pretty
nicely
designed,
but
actually
you
we
also
provide
you
another
way
to
query
asynchronously
customer
here.
B
B
B
It
can
be
for
an
advanced
form,
for
instance,
where
the
user
will
add
a
bunch
of
criteria,
and
your
your
query
will
actually
depend
on
the
criteria
that
has
been
provided,
but
it
can
also
be
used
to
to
create
your
queries
for
your
prepare
statement.
If
you
don't
want
to
to
rely
on
some
long
strings
but
yeah,
you
should
probably
always
consider
using
prepare
statement
if
you're
doing
some
queries
that
are
reused
all
the
time
in
your
application.
Actually.
B
Some
piece
of
architecture-
I've
mentioned
some
load,
balancing
and
failover.
That's
the
workflow
diagram
that
we
use
to
to
to
to
to
make
it
work.
So
basically,
you
can
see
here
that
the
client
will
send
a
query.
It
will
be
pushed
to
the
load
balancing
policy,
the
load
bouncing
policy
is
fed
by
some
else
monitor
some
monitors
that
we've
that
we've
got
on
each
of
the
hosts
of
the
castle
nodes.
B
It
will
be
fed
by
the
notifications
that
we
receive
from
casanova,
but
some
new
nodes
that
are
added
or
removed
and
as
well
by
the
the
possible
reconnections
that
we
were
able
to
have
on
some
nodes
that
failed
previously,
so
ons
the
load
balancing
policy
could
figure
out
which,
which
node
is
the
appropriate
one.
For
this
request,
we
will
send
the
request,
obviously,
to
this
node.
When
the
answer
comes
back,
you
will
possibly
have
a.
We
try
policy,
that's
something
you
can
configure.
B
I
will
not
detail
it
a
lot
here,
but
that's
some
options
that
you've
got
in
order
to
to
decide
how
to
how
to
handle
some
some
unavailability,
ao
or
some
timeout
or
whatever,
and
then
it
will
just
be
pushed
to
a
dispatcher
that
will
decide
that
will
just
dispatch
it
to
the
clients
what
they
is
waiting
for
for.
For
this
result,.
B
But
some
of
you
that
are
following
closely
our
drivers
probably
noticed
that
we've
got
a
java
driver,
2-0,
beta
2,
actually
currently
sorry
and
it
actually
leveraged
a
bunch
of
new
features
from
customer
2..
So
all
the
driver
branch
1.0
target
gas
on
one
two
and
the
branch
2.0
target
customer
2
0.
The
reason
for
that
is
that
we
want
to
avoid
the
drivers
to
handle
multiple
versions
of
casino,
because
that
brings
a
lot
of
complexity.
B
The
idea
is
that
it
will
allow
you
to
iterate
indefinitely,
almost
indefinitely
on
the
wesley
set,
that
can
be
a
terabyte
of
data
and
without
any
issue
or
memory.
You
know
traditionally,
if
you're
a
customer
user,
you
know
that
you're
not
supposed
to
fetch
a
gigabytes
of
data,
because
all
this
data
will
remain
in
memory
both
on
the
server
side
and
the
client
side
and
with
automatic
paging.
B
We
solve
this
issue
by
making
it
possible
to
fetch
only
a
chunk
of
the
data,
and
the
interesting
thing
is:
is
that
here
all
this
is
done
in
a
fully
stateless
way.
That
is
at
first,
you
will
send
the
query
to
a
node
and
what
you
will
receive
is
is
actually
the
first
page,
along
with
a
state
which
will
be
a
bit
like
a
cookie
for
for
your
browsers
and
and
these
states
can
be
reused
in
a
second
query
in
order
to
to
to
to
to
wait
with,
obviously
the
next
page.
B
B
A
So
today
we
are
really
really
excited
to
announce
again
the
dev
center
1.0,
the
guys
back
at
our
headquarters
in
san
francisco,
decided
to
push
the
pr
announcement
yesterday,
probably
because
they
are
envious
on
us
being
on
london
and
on
you
getting
the
chance
to
look
it
look
at
it
first,
but
yeah,
unlike
we
prepared
this
in
for
you,
especially
so
what's
dev
center
dev
center
is
a
free,
visual
query
tool
for
writing.
Sql
and
that's
the
long
definition.
A
But
the
way
I
would
like
to
to
present
dev
center
is
that
it's
the
smarter
and
friendlier
brother
of
sql
sh
and
the
reason
I'm
saying
that
is
smarter.
Is
that
not
only
we
are.
It
supports
a
lot
of
features
that
sql
sh
doesn't,
but
we
can
extend
it
very
far
and
we
have
some
very
weird
dreams
about
the
future
of
this
true
tool.
A
So
with
that
being
said,
our
thinking
was
the
best
way
to
to
to
introduce
dev
center
to
you
and
initially
I
thought
to
try
to
pull
a
steve
jobs,
but
unfortunately
the
turtlenecks
sweaters
are
sold
off.
So
I
don't
have
that
and
the
other
option
would
have
been
to
to
brag
about
death
center
with
a
bunch
of
slides
and
I
hate
being
booed.
So
basically,
I
decided
to
go
with
a
short
demo,
so
we'll
switch
to
demo
mode
and
it
will
take
me
a
couple
of
seconds.
A
I
did
some
tested
tests
before
hand,
so
you
should
be
able
to
see
it
from
the
back
of
the
room.
If
you
don't
please
let
me
know
so.
This
is
dev
center.
It
should
be.
It
should
feel
familiar
right
away
in
the
left
corner.
We
have
some
connection
management
that
you
can
configure
to
to
connect
to
different
clusters.
A
Then
you
have
a
bunch
of
scripts
that
you
can
manage,
and
then
we
have
a
schema
explorer
and
an
outline
of
the
current
script.
So
what
we'll
do
next
is
basically
run
a
quick
demo
by
creating
a
new
key
space,
creating
a
new
table,
inserting
some
data
and
bringing
it
back.
Let's
see
if
it
works,
so
because
my
typing
and
speaking,
is
not
really
my
specialty.
A
A
A
A
A
And
if
you're
paying
attention
to
my
typing
speed,
you'll
notice
that
I
get
auto
completion
suggestions
for
all
these
fields
and
table
names
and
they
don't
exist
yet
look
at
the
key
spaces.
I
don't
have
it
so
we
are
bringing
this
information
from
the
current
script
and
augmenting
it
with
the
real
life.
A
So
while
I
wanted
to
tell
you
that
I
made
these
mistakes
on
purpose-
that's
not
the
case,
but
you
could
see
you
could
see
how
useful
that
the
tool
it
is
like
you
don't
need
to
know.
Sql
by
by
heart.
You
don't
need
to
run
every
statement
to
get
validation.
You
get
real-time
validation
of
your
script.
A
A
B
A
B
We
obviously
definitely
want
to
support
castleman2o
as
soon
as
possible
and
we'd
like
to
to
to
provide
you
some
smart
stuff,
like
you
know,
telling
you
that
these
features
is
not
supported
in
the
in
the
version
of
castle,
where
you're
currently
connected
to
and
so
on,
and
which
we
believe
is
especially
useful
for
something
a
product
that
is
moving
as
fast
as
customer.
You
know.
A
B
B
B
So
I
think
I
think
that
will
be
a
as
a
veritable
question.
So
the
question
is,
we
should
have
an
integer
plugin
and
we'll
see
the
feedback
we
get.
We
get
it's
obviously
because
the
the
the
the
java
world
is,
you
know,
yeah,
it's
separated
between
these
two
big
worlds
and
it's
hard
to
please
both
of
these
two
communities.
B
A
A
different
way
to
think
about
it
is,
we
can
go
breath
first
or
depths
first,
and
we
want
basically
initially
to
go
depth
first
and
then
expand
because
I'm
like
this
is
the
sort
of
tool
that
we
need
you
to
use
to
learn
how
to
improve
it.
And
once
we
keep
pushing
these
things
out,
we'll
start
considering
supporting
different
platforms.
B
So
the
question
is:
do
we
plan
to
support,
prepare
statement
and
extracting
the
code
and
all
that
is
that
the
kind
of
things
that
we
can
definitely
imagine
doing?
You
know
bringing
some
helpers
for
that
in
the
eclipse
plug-in
version,
obviously
with
an
integration
with
with
gdt
with
the
java
editor,
as
you
can
see
right
now
we
don't
support
it,
but
yeah.
That's
in
our
project,
slash
dreams.
B
Right
now,
you
cannot
do
that
some
guys
internally,
interestingly
proposed
similar
features
being
able
to
maybe
to
do
some
step-by-step
execution.
You
know
which
can
be
very
convenient
because,
obviously,
if
your
script
is
getting
very
long,
so
you
can
imagine
here
probably
having
a
big
ddl
script
for
to
initialize
your
your
your
production
application
or
something
like
that,
or
maybe
to
upgrade
your
production
application.
That
can
be
handy
and
that's
something
you
I'm
not
sure.
Yet
I
don't
know
yet
we'll
see
what
we
can
do
with
that
and
how
we
prioritize
it.
B
B
Yeah,
that's
also
part
of
our
ideas,
we'll
see
how
how
we
prioritize
it
and
and
that's
interesting
actually
that
there's
so
much
ideas,
don't
hesitate
to
to
come
back
to
us
with
proposition
and
or
to
to
to
to
suggest
or
push
features
with
us
and
otherwise
these
weathers
and
others.
We
don't
pretend
to
know
what
has
to
be
done.
It's
also,
depending
on
the
feedbacks
from
everybody
and
the
feedback
from
customers,
but
also
from
users.
I'm.
A
B
A
B
B
The
good
news
is
that
it's
free,
oh
okay.
So
the
good
news
is
that
it's
free
right
now
it's
closed
source,
because
we
we
don't
realize
whether
it's
worthwhile
to
have
an
open
source
tool
for
for
something
like
this.
For
for
for
such
an
ide
here
again,
depending
on
the
feedback
that
we
get.
If
there's
a
huge
demand
for
open
sourcing,
it
which
it's
hard
to
predict,
actually
that's
something
that
can
could
be
considered.
B
B
Yeah,
so
that's
that's
part
of
the
cql
language.
You
can
alter
the
schema.
Not
any
kind
of
alteration
are
possible
right
now
you
can
add
some
columns.
You
can
change
that
type
of
a
column
and
and
change.
The
third
kind
of
ideas
that
you
can
do
on
the
table
is
to
change
the
the
options
of
your
table.
You
know
like
that.
So.