DOC-3179: apply reviewer comments

Author: dwdougherty

src/ds/hashes.md

@@ -1,15 +1,17 @@
 Lists, sets, and sorted sets are great for many use cases, but the hash data type is on a higher level. Redis hashes are maps (sequences of field-value pairs) and are used to represent objects in Redis. Consider the following example that shows how to create a hash key using the `HSET` command.
 
+Redis hashes are record types that are structured as name-value pairs. Consider the following example that shows how to create a hash key using the `HSET` command.
+
 ```redis Create a hash
 HSET bike:1 model Deimos brand Ergonom type "Enduro bikes" price 4972
 ```
 
-`HSET` returns the number of added key/value pairs.
+`HSET` returns the number of added name-value pairs.
 
 To retrieve the stored data, use the `HGETALL` command.
 
 ```redis HGETALL usage
-HGETALL bike:1 // returns all the field-value pairs associated with the key
+HGETALL bike:1 // returns all the name-value pairs associated with the key
 ```
 
 If you only want the values of a subset of the fields, use the `HGET` command.
@@ -18,7 +20,7 @@ If you only want the values of a subset of the fields, use the `HGET` command.
 HGET bike:1 price
 ```
 
-You can update fields in a hash using `HSET` by specifying a subset of its field-value pairs.
+You can update fields in a hash using `HSET` by specifying a subset of its name-value pairs.
 
 ```redis Update an existing hash
 HSET bike:1 model "Kraken" price 3000
@@ -34,14 +36,12 @@ HGETALL bike:1
 EXISTS bike:1
 ```
 
-Numerical values in hash keys can be incremented in the same way as simple string keys using the `HINCRBY` command.
+Integer values in hash keys can be incremented or decremented in the same way as simple string keys using the `HINCRBY` command.
+The increment value must be a positive or negative integer.
 
 ```redis Hash INCRBY usage
 HINCRBY bike:1 price 100
 HINCRBY bike:1 price -100
 ```
 
 See [here](https://redis.io/docs/data-types/hashes) for the hash type reference page, and [here](https://redis.io/commands/?group=hash) for the entire set of Redis hash commands.
-
-**Note**:
-> If you're more familiar with JSON and want to use it with Redis, there is a [JSON data type](https://redis.io/docs/data-types/json) that is provided as part of Redis Stack. There's also a tutorial titled "Working with JSON" that is bundled with RedisInsight.

src/ds/json/adv-jsonpath.md

@@ -17,19 +17,17 @@ JSON.SET arr1 $ [1,2,3]
 JSON.SET arrmap $ '[{"a":1}, {"b":2}]'
 ```
 
-The returned value of a JSONPath expression is a JSON string with a top-level array of JSON serialized strings.
-
 **Note**:
->A JSONPath query can resolve to several locations in a JSON document. When more than one location is identified, the JSON commands apply the operation to every possible location.
+>A JSONPath query can resolve to multiple absolute path matches. When more than one matching path is identified, the JSON commands apply the operation to every possible path.
 
 ## JSONPath syntax
 
 | Syntax element | Description |
 |----------------|-------------|
 | `$` | The root (outermost JSON element), starts the path. |
-| `.` or `[]` | Selects a child element. |
+| `.` | Selects a child element. |
 | `..` | Recursively descends through the JSON document. |
-| `*` | Wildcard, returns all elements. |
+| `*` | If current node is an array, `*` resolves to all array elements. If current node is an object, `*` resolves to all the object's members |
 | `[]` | Subscript operator, accesses an array element. |
 | `[,]` | Union, selects multiple elements. |
 | `[start:end:step]` | Array slice where `start`, `end`, and `step` are indexes. |
@@ -135,25 +133,25 @@ JSON.GET obj2 $.b[0]
 JSON.GET obj2 $.*[0]
 ```
 
-Redis Stack also supports slice syntax for arrays: `[start:`end`:`step`]`, where `start`, ``end``, and ``step`` are indexes.
-The following rules apply:
-
-- If the current node is an array, an array containing elements extracted from an array are returned, based on a start index, an `end` index, and a `step` index.
-Array indexes are 0-based. Start Index is inclusive; End index is not inclusive.
+Redis Stack also supports slice syntax for arrays: `[start:`end`:`step`]`, where `start`, `end`, and `step` are indexes.
+If the current node is an array, an array containing elements extracted from an array are returned, based on a `start` index, an `end` index, and a `step` index.
+Array indexes are zero-based; the first element is index 0. Start Index is inclusive; End index is not inclusive.
 The following rules apply:
 
-  - If `start` is specified, it must be an integer.
-  - if `start` is omitted, it is replaced with 0.
-  - if `start` < 0, it is replaced with min(0, `start` + array-length).
-  - if `start` > array-length, an empty array is returned.
-  - if `end` is specified, it must be an integer.
-  - If `end` is omitted, it is replaced with array-length.
-  - If `end` ≥ array-length, it is replaced with array-length.
-  - if `end` < 0, it is replaced with min(0, `end` + array-length).
-  - If `end` ≤ `start` (after normalization), an empty array is returned.
-  - if `step` is specified, it must be a positive integer.
-  - if `step` is omitted, it is replaced with 1.
-  - If the current node in not an array, an empty array is returned.
+| Predicate | Rule |
+| --------- | ---- |
+| If `start` is specified | it must be an integer |
+| if `start` is omitted | it is replaced with 0 |
+| if `start` < 0 | it is replaced with min(0, `start` + array-length) |
+| if `start` > array-length | an empty array is returned |
+| if `end` is specified | it must be an integer |
+| If `end` is omitted | it is replaced with array-length |
+| If `end` ≥ array-length | it is replaced with array-length |
+| if `end` < 0 | it is replaced with min(0, `end` + array-length) |
+| If `end` ≤ `start` (after normalization) | an empty array is returned |
+| If `step` is specified | it must be a positive integer |
+| If `step` is omitted | it is replaced with 1 |
+| If the current node in not an array | an empty array is returned |
 
 ```redis Array slice examples
 JSON.GET arr1 $[:]

src/ds/json/create.md

@@ -12,7 +12,7 @@ JSON.SET bicycle:1 $ '{
         "material": "aluminium",
         "weight": "10"
       },
-    "description": "Small and powerful, the Jigger is the best ride for the smallest of tikes! This is the tiniest kids\u2019 pedal bike on the market available without a coaster brake, the Jigger is the vehicle of choice for the rare tenacious little rider raring to go. We say rare because this smokin\u2019 little bike is not ideal for a nervous first-time rider, but it\u2019s a true giddy up for a true speedster. The Jigger is a 12 inch lightweight kids bicycle and it will meet your little one\u2019s need for speed. It\u2019s a single speed bike that makes learning to pump pedals simple and intuitive. It even has  a handle in the bottom of the saddle so you can easily help your child during training!  The Jigger is among the most lightweight children\u2019s bikes on the planet. It is designed so that 2-3 year-olds fit comfortably in a molded ride position that allows for efficient riding, balanced handling and agility. The Jigger\u2019s frame design and gears work together so your buddingbiker can stand up out of the seat, stop rapidly, rip over trails and pump tracks. The Jigger\u2019s is amazing on dirt or pavement. Your tike will speed down the bike path in no time. The Jigger will ship with a coaster brake. A freewheel kit is provided at no cost.",
+    "description": "The Jigger is the best ride for the smallest of tikes!",
     "addons": [
         "reflectors",
         "grip tassles"
@@ -50,7 +50,7 @@ JSON.GET bicycle:1 $.addons[0]
 You can create multiple documents in a single command using `JSON.MSET`:
 
 ```redis Add two more documents using JSON.MGET
-JSON.MSET "bicycle:2" $ "{\"model\": \"Hillcraft\", \"brand\": \"Bicyk\", \"price\": 1200, \"type\": \"Kids Mountain Bikes\", \"specs\": {\"material\": \"carbon\", \"weight\": \"11\"}, \"description\": \"Kids want to ride with as little weight as possible. Especially on an incline! They may be at the age when a 27.5\\\" wheel bike is just too clumsy coming off a 24\\\" bike. The Hillcraft 26 is just the solution they need! Imagine 120mm travel. Boost front/rear.  You have NOTHING to tweak because it is easy to assemble right out of the box. The Hillcraft 26 is an efficient trail trekking machine. Up or down does not matter - dominate the trails going both down and up with this amazing bike. The name Monarch comes from Monarch trail in Colorado where we love to ride.  It\u2019s a highly technical, steep and rocky trail but the rip on the waydown is so fulfilling.  Don\u2019t ride the trail on a hardtail! It is so much more fun on the full suspension Hillcraft!  Hit your local trail with the Hillcraft Monarch 26 to get to where you want to go.\", \"addons\": [\"reflectors\", \"safety lights\"],\"helmet_included\": false}" "bicycle:3" $ "{\"model\": \"Chook air 5\", \"brand\": \"Nord\", \"price\": 815, \"type\": \"Kids Mountain Bikes\", \"specs\": {\"material\": \"alloy\", \"weight\": \"9.1\"}, \"description\": \"The Chook Air 5  gives kids aged six years and older a durable and uberlight mountain bike for their first experience on tracks and easy cruising through forests and fields. The lower  top tube makes it easy to mount and dismount in any situation, giving your kids greater safety on the trails. The Chook Air 5 is the perfect intro to mountain biking.\", \"addons\": [\"reflectors\", \"safety lights\"],\"helmet_included\": false}"
+JSON.MSET "bicycle:2" $ "{\"model\": \"Hillcraft\", \"brand\": \"Bicyk\", \"price\": 1200, \"type\": \"Kids Mountain Bikes\", \"specs\": {\"material\": \"carbon\", \"weight\": \"11\"}, \"description\": \"A light mountain bike for kids.\", \"addons\": [\"reflectors\", \"safety lights\"],\"helmet_included\": false}" "bicycle:3" $ "{\"model\": \"Chook air 5\", \"brand\": \"Nord\", \"price\": 815, \"type\": \"Kids Mountain Bikes\", \"specs\": {\"material\": \"alloy\", \"weight\": \"9.1\"}, \"description\": \"A lighter, more durable mountain bike for six years and older.\", \"addons\": [\"reflectors\", \"safety lights\"],\"helmet_included\": false}"
 ```
 
 You can retrieve multiple documents or parts of documents in a single command using `JSON.MGET`:

src/ds/json/learn-more.md

@@ -9,6 +9,6 @@
 
 ### Blogs
 
-* [RedisJSON: Public Preview & Performance Benchmarking](https://redis.com/blog/redisjson-public-preview-performance-benchmarking/)
+* [RedisJSON: Public Preview & Performance Benchmarking](https://redis.com/blog/redisjson-public-preview-performance-benchmarking/?utm_source=redisinsight&utm_medium=main&utm_campaign=tutorials)
 * [Indexing, Querying, and Full-Text Search of JSON Documents with Redis](https://redis.com/blog/index-and-query-json-docs-with-redis/)
 

src/ds/json/modify.md

@@ -4,40 +4,33 @@ Here are some examples.
 
 ## Extend documents
 
-```redis Add a new key:value pair to an existing document
-JSON.SET bicycle:1 $.newkey '"value"'
+```redis Add a new name-value pair to an existing document
+JSON.SET bicycle:1 $.newmember '"value"'
 ```
 
-You could also use `JSON.MSET` to create or update multiple documents at the same time. First, delete `$.newkey` from `bicycle:1` using `JSON.DEL`.
+You could also use `JSON.MSET` to create or update multiple documents at the same time. First, delete `$.newmember` from `bicycle:1` using `JSON.DEL`.
 
-```redis Delete $.newkey from bicycle:1
-JSON.DEL bicycle:1 $.newkey
+```redis Delete $.newmember from bicycle:1
+JSON.DEL bicycle:1 $.newmember
 ```
 
-Next, add `$.newkey` to all three bicycles:
+Next, add `$.newmember` to all three bicycles:
 
-```redis Add $.newkey too all three bicycles using JSON.MSET
-JSON.MSET bicycle:1 $.newkey '"value1"' bicycle:2 $.newkey '"value2"' bicycle:3 $.newkey '"value3"'
-JSON.MGET bicycle:1 bicycle:2 bicycle:3 $.newkey
+```redis Add a member named newmember too all three bicycles using JSON.MSET
+JSON.MSET bicycle:1 $.newmember '"value1"' bicycle:2 $.newmember '"value2"' bicycle:3 $.newmember '"value3"'
+JSON.MGET bicycle:1 bicycle:2 bicycle:3 $.newmember
 ```
 
 ## Manipulate numeric values
 
-There are two commands that allow you to perform arithmetic operations on components of documents:
-
-- `JSON.NUMINCRBY` - adds a value to a numeric field.
+The `JSON.NUMINCRBY` command allows you to perform arithmetic operations on numeric fields of documents.
+Use positive numbers to increment and negative numbers to decrement.
 
 ```redis Decrease the price of bicycle:1
 JSON.GET bicycle:1 $.price
 JSON.NUMINCRBY bicycle:1 $.price -10
 JSON.GET bicycle:1 $.price
 ```
-
-- `JSON.NUMMULTBY` - multiply a numeric field by a value.
-
-```redis Discount bicycle:1 by 10%
-JSON.NUMMULTBY bicycle:1 $.price 0.9
-```
 ## Manipulate string and boolean values
 
 Appending information to JSON strings is straightforward.
@@ -61,8 +54,8 @@ As you saw earlier, the `JSON.MERGE` command can be used to create new documents
 
 - Create a non-existant path-value:
 
-```redis Add a new field-value pair to bicycle:1
-JSON.MERGE bicycle:1 $.newkey2 '"value 2 1"'
+```redis Add a new name-value pair to bicycle:1
+JSON.MERGE bicycle:1 $.newmember2 '"value 2 1"'
 JSON.GET bicycle:1
 ```
 
@@ -75,8 +68,8 @@ JSON.GET bicycle:1 $.model
 
 - Delete an existing value:
 
-```redis Delete newkey2 from bicycle:1
-JSON.MERGE bicycle:1 $ '{"newkey2": null}'
+```redis Delete newmember2 from bicycle:1
+JSON.MERGE bicycle:1 $ '{"newmember2": null}'
 JSON.GET bicycle:1
 ```
 
@@ -91,10 +84,10 @@ JSON.GET bicycle:1 $.addons
 
 ## Delete information
 
-You can delete field-value pairs using the `JSON.DEL` or `JSON.FORGET` commands:
+You can delete name-value pairs using the `JSON.DEL` or `JSON.FORGET` commands:
 
-```redis Delete newkey from bicycle:1
-JSON.DEL bicycle:1 $.newkey
+```redis Delete newmember from bicycle:1
+JSON.DEL bicycle:1 $.newmember
 JSON.GET bicycle:1
 ```
 

src/ds/json/objects.md

@@ -16,10 +16,10 @@ JSON.OBJKEYS doc $.o
 
 - `JSON.OBJLEN` - get the number of fields of a JSON object.
 
-```redis Get the number of fields in the doc object
+```redis Get the number of members of the object at the root of document doc
 JSON.OBJLEN doc
 ```
 
-```redis Get the number of fields in the $.o object
+```redis Get the number of members of the $.o object of document doc
 JSON.OBJLEN doc $.o
 ```

src/ds/lists.md

@@ -13,7 +13,7 @@ You interact with lists using commands such as:
 - LPOP - removes and returns an item from the beginning of a list.
 - RPOP - removes and returns an item from the end of a list.
 
-You can begin working with a list without first creating its key, simply by adding values to the key. This works as long as the key doesn't already exist as a different type.
+You can begin using with a list without first creating its key, simply by adding values to the key. This works as long as the key doesn't already exist as a different type.
 
 **Note**:
 > This is generally true for every Redis data structure, though there are a few exceptions.
@@ -55,7 +55,7 @@ LRANGE bike:colors 1 2
 LRANGE bike:colors 1 -2
 ```
 
-To find out how many elements are in a list, use the `LLEN` command.
+To retrieve the number of elements in a list, use the `LLEN` command.
 
 ```redis LLEN usage
 LLEN bike:colors

src/ds/prob/bloom-cuckoo.md

@@ -54,22 +54,25 @@ You can read more about Bloom filters and their use cases [here](https://redis.i
 
 ## Cuckoo Filters
 
-[Cuckoo filters](https://en.wikipedia.org/wiki/Cuckoo_filter), which are similar to Bloom filters, are used to determine, with a high degree of certainty, whether or not an element is a member of a set. Unlike Bloom filters, you can delete items from a cuckoo filter.
+[Cuckoo filters](https://en.wikipedia.org/wiki/Cuckoo_filter), which are similar to Bloom filters, are used to determine, with a high degree of certainty, whether or not an element is a member of a filter. Unlike Bloom filters, you can delete items from a cuckoo filter. Unlike Bloom filters, you can add the same element multiple times to a Cuckoo filter (see the `CF.COUNT` example below).
 
 To begin, create a cuckoo filter with estimated capacity, defined bucket size (the number of items in each bucket), and maximum number of iterations (number of attempts to swap items between buckets).
 
 ```redis Create a cuckoo filter
 CF.RESERVE bikes:models 100 BUCKETSIZE 10 MAXITERATIONS 2 // creates a “cuckoo” filter for the initial amount of 100 items, 10 items per bucket and 2 iterations to swap items before creating an additional filter
 ```
 
+**Note:**
+> `BUCKETSIZE`, `MAXITERATIONS`, and `EXPANSION` are optional arguments and default to `2`, `20`, `1`, respectively.
+
 Next, add items to the cuckoo filter.
 Note that `CF.ADD` creates a new filter if one doesn't already exist.
 
 ```redis Add Items
-CMS.ADD bikes:models "Smokey Mountain Striker"
-CMS.ADD bikes:models "Cloudy City Cruiser"
-CMS.ADD bikes:models "Rocky Mountain Racer"
-CMS.ADD bikes:models "Smokey Mountain Striker" // second addition of Smokey...
+CF.ADD bikes:models "Smokey Mountain Striker"
+CF.ADD bikes:models "Cloudy City Cruiser"
+CF.ADD bikes:models "Rocky Mountain Racer"
+CF.ADD bikes:models "Smokey Mountain Striker" // second addition of Smokey...
 ```
 
 Use the `CF.EXISTS` command to determine whether or not an item may exist in the cuckoo filter.

src/ds/prob/count-min-sketch.md

@@ -1,6 +1,6 @@
 In this tutorial you will learn how to use a count-min sketch to track profits in a bike shop use case.
 
-A count-min sketch is used to determine the frequency of events in a stream. You can query the count-min sketch to get an estimate of the frequency of any given event.
+A count-min sketch is used to determine the frequency of distinct values in a stream. You can query the count-min sketch to get an estimate of the frequency of any given value.
 
 You can initialize the count-min sketch and specify a width (the number of counters in each array) and depth (the number of counter-arrays).
 
@@ -16,14 +16,14 @@ You can also initialize a count-min sketch by providing an acceptable error rate
 CMS.INITBYPROB bikes:profits 0.001 0.01 // initializes the count-min sketch with 0.1% estimation of error and 1% desired probability for inflated count
 ```
 
-You can increase the count associated with an item by a supplied increment:
+You can increase the frequency associated with an item by a supplied increment:
 
 ```redis Update
 CMS.INCRBY bikes:profit "Smokey Mountain Striker" 100
 CMS.INCRBY bikes:profit "Rocky Mountain Racer" 200 "Cloudy City Cruiser" 150
 ```
 
-Retrieve the counts for several items from the sketch:
+Retrieve the frequencies for several items from the sketch:
 
 ```redis Return query
 CMS.QUERY bikes:profit "Smokey Mountain Striker" "Rocky Mountain Racer" "Cloudy City Cruiser" "Terrible Bike Name"

src/ds/prob/hyperloglog.md

@@ -1,9 +1,9 @@
 In this tutorial you will learn how to use the HyperLogLog (HLL) probabilistic data structure in a bike shop use case.
 
-HyperLogLog is a probabilistic data structure that estimates the cardinality of a set. As a probabilistic data structure, HLL trades perfect accuracy for efficient space utilization.
+HyperLogLog is a probabilistic data structure that estimates the number of unique elements (cardinality) of a set. As a probabilistic data structure, HLL trades perfect accuracy for efficient space utilization.
 The Redis HLL implementation uses at most 12 KB of memory and provides a standard error of 0.81%.
 
-A common use case for HLLs is to track the number anonymous unique visits to a web resource. HLLs help answer questions like:
+A common use case for HLLs is to track the number unique visits to a web resource. HLLs help answer questions like:
 
 - How many unique visits has this page had on this day?
 - How many unique users have played this song?