anchor.diff:  quarkus.cassandra.keyspace=k1
   ----
   
  -=== Advanced driver configuration
  +=== Advanced Driver Configuration
   
   You can configure other Java driver settings using `application.conf` or `application.json` files.
  -They need to be located in the classpath of your application.
  -All settings will be passed automatically to the underlying driver configuration mechanism.
  -Settings defined in `application.properties` with the `quarkus.cassandra` prefix will have priority
  -over settings defined in `application.conf` or `application.json`.
  +They need to be located in the classpath of your application. All settings will be passed
  +automatically to the underlying driver configuration mechanism. Settings defined in
  +`application.properties` with the `quarkus.cassandra` prefix will have priority over settings
  +defined in `application.conf` or `application.json`.
   
   To see the full list of settings, please refer to the
  -link:https://docs.datastax.com/en/developer/java-driver/latest/manual/core/configuration/reference/[driver settings reference].
  -
  -== Running a Cassandra Database
  -
  -By default, `CassandraClient` is configured to access a local Cassandra database on port 9042 (the
  -default Cassandra port).
  -
  -IMPORTANT: Make sure that the setting `quarkus.cassandra.local-datacenter`
  -matches the datacenter of your Cassandra cluster.
  +link:https://docs.datastax.com/en/developer/java-driver/latest/manual/core/configuration/reference/[driver
  +settings reference].
  +
  +== Running a Local Cassandra Database
  +
  +By default, the Cassandra client is configured to access a local Cassandra database on port 9042
  +(the default Cassandra port).
  +
  +IMPORTANT: Make sure that the setting `quarkus.cassandra.local-datacenter` matches the datacenter of
  +your Cassandra cluster.
   
   TIP: If you don't know the name of your local datacenter, this value can be found by running the
   following CQL query: `SELECT data_center FROM system.local`.
   
   If you want to use Docker to run a Cassandra database, you can use the following command to launch
  -one:
  -
  -[source,bash]
  -----
  -docker run \
  -   --name local-cassandra-instance \
  -   -p 7000:7000 \
  -   -p 7001:7001 \
  -   -p 7199:7199 \
  -   -p 9042:9042 \
  -   -p 9160:9160 \
  -   -p 9404:9404 \
  -   -d \
  -   launcher.gcr.io/google/cassandra3
  -----
  -
  -Note that only the 9042 port is required. All others all optional but provide enhanced features
  -like JMX monitoring of the Cassandra instance.
  +one in the background:
  +
  +[source,shell]
  +----
  +docker run --name local-cassandra-instance -p 9042:9042 -d cassandra
  +----
   
   Next you need to create the keyspace and table that will be used by your application. If you are
   using Docker, run the following commands:
   
  -[source,bash]
  +[source,shell]
   ----
   docker exec -it local-cassandra-instance cqlsh -e "CREATE KEYSPACE IF NOT EXISTS k1 WITH replication = {'class':'SimpleStrategy', 'replication_factor':1}"
  -docker exec -it local-cassandra-instance cqlsh -e "CREATE TABLE IF NOT EXISTS k1.fruit(store_id text, name text, description text, PRIMARY KEY((store_id), name))"
  -----
  -
  -If you're running Cassandra locally you can execute the cqlsh commands directly:
  -
  -[source,bash]
  -----
  -cqlsh -e "CREATE KEYSPACE IF NOT EXISTS k1 WITH replication = {'class':'SimpleStrategy', 'replication_factor':1}
  -cqlsh -e "CREATE TABLE IF NOT EXISTS k1.fruit(store_id text, name text, description text, PRIMARY KEY((store_id), name))
  -----
  -
  -== Creating a frontend
  +docker exec -it local-cassandra-instance cqlsh -e "CREATE TABLE IF NOT EXISTS k1.fruit(name text PRIMARY KEY, description text)"
  +----
  +
  +You can also use the CQLSH utility to interactively interrogate your database:
  +
  +[source,shell]
  +----
  +docker exec -it local-cassandra-instance cqlsh
  +----
  +
  +== Testing the REST API
  +
  +In the project root directory:
  +
  +- Run `mvn clean package` and then `java -jar ./target/cassandra-quarkus-quickstart-*-runner.jar` to start the application;
  +- Or better yet, run the application in dev mode: `mvn clean quarkus:dev`.
  +
  +Now you can use curl commands to interact with the underlying REST API.
  +
  +To create a fruit:
  +
  +[source,shell]
  +----
  +curl --header "Content-Type: application/json" \
  +  --request POST \
  +  --data '{"name":"apple","description":"red and tasty"}' \
  +  http://localhost:8080/fruits
  +----
  +
  +To retrieve fruits:
  +
  +[source,shell]
  +----
  +curl -X GET http://localhost:8080/fruits
  +----
  +
  +== Creating a Frontend
   
   Now let's add a simple web page to interact with our `FruitResource`.
   
  -Quarkus automatically serves static resources located under the `META-INF/resources` directory.
  -In the `src/main/resources/META-INF/resources` directory, add a `fruits.html` file with the content
  -from this link:https://github.com/datastax/cassandra-quarkus/tree/master/quickstart/src/main/resources/META-INF/resources/fruits.html[fruits.html] file in it.
  +Quarkus automatically serves static resources located under the `META-INF/resources` directory. In
  +the `src/main/resources/META-INF/resources` directory, add a `fruits.html` file with the contents
  +from link:src/main/resources/META-INF/resources/fruits.html[this file] in it.
   
   You can now interact with your REST service:
   
  -* start Quarkus with `mvn clean quarkus:dev`
  -* open a browser to `http://localhost:8080/fruits.html`
  -* add new fruits to the list via the form
  +* If you haven't done yet, start your application with `mvn clean quarkus:dev`;
  +* Point your browser to `http://localhost:8080/fruits.html`;
  +* Add new fruits to the list via the form.
   
   [[reactive]]
  -== Reactive Cassandra Client
  -
  -When using `QuarkusCqlSession` you have access to reactive variant of methods that integrate with
  -Quarkus and Mutiny.
  +== Reactive Programming with the Cassandra Client
  +
  +The
  +link:https://javadoc.io/doc/com.datastax.oss.quarkus/cassandra-quarkus-client/latest/com/datastax/oss/quarkus/runtime/api/session/QuarkusCqlSession.html[`QuarkusCqlSession`
  +interface] gives you access to a series of reactive methods that integrate seamlessly with Quarkus
  +and its reactive framework, Mutiny.
   
   TIP:  If you're not familiar with Mutiny, read the
  -link:getting-started-reactive[Getting Started with Reactive guide] first.
  -
  -Let's rewrite the previous example using reactive programming with Mutiny.
  -
  -Firstly, we need to implement the `@Dao` that works in a reactive way:
  +link:https://quarkus.io/guides/getting-started-reactive[Getting Started with Reactive guide] first.
  +
  +Let's rewrite our application using reactive programming with Mutiny.
  +
  +First, let's to declare another DAO interface that works in a reactive way:
   
   [source,java]
   ----
   @Dao
  -public interface FruitDaoReactive {
  +public interface ReactiveFruitDao {
   
     @Update
  -  Uni<Void> updateAsync(Fruit fruitDao);
  +  Uni<Void> updateAsync(Fruit fruit);
   
     @Select
  -  MutinyMappedReactiveResultSet<Fruit> findByIdAsync(String id);
  -}
  -
  -----
  -
  -Please note the usage of `MutinyMappedReactiveResultSet` - it is a specialized `Mutiny` type
  -converted from the original `Publisher` returned by the driver, which also exposes a few extra
  -methods, e.g. to obtain the query execution info. If you don't need anything in that interface,
  -you can also simply declare your method to return `Multi`: `Multi<Fruit> findByIdAsync(String id)`,
  +  MutinyMappedReactiveResultSet<Fruit> findAll();
  +}
  +
  +----
  +
  +Note the usage of `MutinyMappedReactiveResultSet` - it is a specialized `Mutiny` type converted from
  +the original `Publisher` returned by the driver, which also exposes a few extra methods, e.g. to
  +obtain the query execution info. If you don't need anything in that interface, you can also simply
  +declare your method to return `Multi`: `Multi<Fruit> findAll()`,
   
   Similarly, the method `updateAsync` returns a `Uni` - it is automatically converted from the
   original result set returned by the driver.
  
positive.code: quarkus.cassandra.keyspace=k1
  ----
  
  If your cluster requires plain text authentication, you can also provide two more settings:
  `username` and `password`.
  
  [source,properties]
  
negative.code:   void update(Fruit fruit);
  
    @Select
    PagingIterable<Fruit> findAll();
  }
  ----
  
  This interface exposes operations that will be used in our REST service. Again, the annotation
  `@Dao` comes from the DataStax Object Mapper, which will also automatically generate an
  implementation of this interface for you.
  
  Note also the special return type of the `findAll` method,
  link:https://docs.datastax.com/en/drivers/java/latest/com/datastax/oss/driver/api/core/PagingIterable.html[`PagingIterable`]:
  it's the base type of result sets returned by the driver.
  
  Finally, let's create the a Mapper interface:
  
  [source,java]
  ----
  