DOC-3100: more re-org and additional content

Author: dwdougherty

src/manifest.json

@@ -9,8 +9,8 @@
   "children": [
     {
       "type": "group",
-      "id": "redis",
-      "label": "Redis",
+      "id": "redis_basic",
+      "label": "Basic data structures",
       "args": {
         "initialIsOpen": false
       },
@@ -75,8 +75,8 @@
     },
     {
       "type": "group",
-      "id": "redis_stack",
-      "label": "Redis Stack",
+      "id": "redis_advanced",
+      "label": "Advanced data structures",
       "args": {
         "initialIsOpen": false
       },

src/redis/introduction.md

@@ -1,7 +1,7 @@
 In this set of tutorials, you will be introduced to the following set of Redis data structure types using a hypothetical bike shop use case:
 
-- [strings](https://redis.io/docs/data-types/strings)
-- [lists](https://redis.io/docs/data-types/lists)
-- [sets](https://redis.io/docs/data-types/sets)
-- [sorted sets](https://redis.io/docs/data-types/sorted-sets)
-- [hashes](https://redis.io/docs/data-types/hashes)
+- strings - used for storing sequences of bytes, including text, images, and serialized objects.
+- lists - ordered linked lists of string values that can be used to implement stacks (LIFO), queues (FIFO), producer-consumer patterns, and more.
+- sets - unordered collections of unique strings that can be used to represent relations and track unique items.
+- sorted sets - collections of unique strings, which are ordered by an associated score, that can be used for rate limiters and game leaderboards.
+- hashes - record types, structured as collections of field-value pairs, used to represent objects.

src/redis/learn_more.md

@@ -1,2 +1,2 @@
-In these general Redis tutorials, you've been introduced to Redis string, list, set, sorted set, and hash data structure types.
+In these Redis basic commands tutorials, you've been introduced to the Redis string, list, set, sorted set, and hash data structure types.
 There are many more Redis data structure types that you can use for a variety of use cases. See [the Redis documentation](https://redis.io/docs/data-types) for the entire list of supported data types.

src/redis/working_with_hashes.md

@@ -1,31 +1,47 @@
-Lists, sets, and sorted sets are great for many use cases, but the [hash](https://redis.io/docs/data-types/hashes) data type is on a higher level. Redis hashes are maps (sequences of key-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](https://redis.io/commands/hset) command.
+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 Create a hash
 HSET bike:1 model Deimos brand Ergonom type "Enduro bikes" price 4972
 ```
 
 `HSET` returns the number of added key/value pairs.
 
-To retrieve the stored data, use the [HGETALL](https://redis.io/commands/hgetall) command.
+To retrieve the stored data, use the `HGETALL` command.
 
 ```redis HGETALL usage
-HGETALL bike:1
+HGETALL bike:1 // returns all the field-value pairs associated with the key
 ```
 
-If you only want the values of a subset of the fields, use the [HGET](https://redis.io/commands/hget) command.
+If you only want the values of a subset of the fields, use the `HGET` command.
 
 ```redis HGET usage
 HGET bike:1 price
 ```
 
-Numerical values in hash keys can be incremented in the same way as simple string keys using the [HINCRBY](https://redis.io/commands/hincrby) command.
+You can update fields in a hash using `HSET` by specifying a subset of its field-value pairs.
+
+```redis Update an existing hash
+HSET bike:1 model "Kraken" price 3000
+```
+
+Use the `HDEL` command to delete one or more fields from a hash. Once all fields are removed, the hash key itself will be deleted.
+
+```redis Delete hash fields and keys
+HDEL bike:1 model
+HGETALL bike:1
+HDEL bike:1 brand type price
+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.
 
 ```redis Hash INCRBY usage
 HINCRBY bike:1 price 100
 HINCRBY bike:1 price -100
 ```
 
-See [here](https://redis.io/commands/?group=hash) for the entire set of Redis hash-related commands.
+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/redis/working_with_lists.md

@@ -1,11 +1,17 @@
-A Redis [list](https://redis.io/docs/data-types/lists) is a data type that contains a series of ordered values. You interact with lists using commands such as:
+A Redis list is a data type that contains a series of ordered string values. Use cases include
 
-- [RPUSH](https://redis.io/commands/rpush) - adds items to the end of a list.
-- [LPUSH](https://redis.io/commands/lpush) - adds items to the beginning of a list.
-- [LLEN](https://redis.io/commands/llen) - retrieves the length of a list.
-- [LRANGE](https://redis.io/commands/lrange) - retrieves list items from a specified range.
-- [LPOP](https://redis.io/commands/lpop) - removes and returns an item from the beginning of a list.
-- [RPOP](https://redis.io/commands/rpop) - removes and returns an item from the end of a list.
+- implementing stacks (LIFO data structures)
+- implementing queues (FIFO data structures)
+- implementing producer-consumer patterns
+
+You interact with lists using commands such as:
+
+- RPUSH - adds items to the end of a list.
+- LPUSH - adds items to the beginning of a list.
+- LLEN - retrieves the length of a list.
+- LRANGE - retrieves list items from a specified range.
+- 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.
 
@@ -72,4 +78,4 @@ KEYS bike:colors
 **Note**:
 > `LRANGE` will return an empty (null) list if a key no longer exists.
 
-See [here](https://redis.io/commands/?group=list) for the entire set of Redis list-related commands.
+See [here](https://redis.io/docs/data-types/list) for the list type reference page, and [here](https://redis.io/commands/?group=list) for the entire set of Redis list commands.

src/redis/working_with_sets.md

@@ -1,16 +1,16 @@
-Redis [sets](https://redis.io/docs/data-types/sets/) are similar to lists, except they are unordered, and each element must be unique. You can use sets to:
+Redis sets are similar to lists, except they are unordered, and each element must be unique. You can use sets to:
 
 - Track unique items (e.g., track all unique IP addresses accessing a given blog post).
 - Represent relations (e.g., the set of all users with a specified role).
 - Perform common set operations such as intersection, union, and difference.
 
 Here are some important set commands:
 
-- [SADD](https://redis.io/commands/sadd)
-- [SREM](https://redis.io/commands/srem)
-- [SISMEMBER](https://redis.io/commands/sismember)
-- [SMEMBERS](https://redis.io/commands/smembers)
-- [SUNION](https://redis.io/commands/sunion)
+- `SADD`
+- `SREM`
+- `SISMEMBER`
+- `SMEMBERS`
+- `SUNION`
 
 Use `SADD` to create and update a set. Each `SADD` command will return the number of added members. If you try to add a member that is already in the set, `0` is returned.
 
@@ -22,7 +22,7 @@ SADD bike:1:addons "bell"
 
 Notice that the `SADD` command is variadic.
 
-`SREM` is used to remove members of a list. It returns `1` if the member is in the set, or `0` if it is not.
+`SREM` is used to remove members of a set. It returns `1` if the member is in the set, or `0` if it is not.
 
 ```redis Remove set members
 SREM bike:1:addons "bell"
@@ -51,8 +51,8 @@ SUNION bike:1:addons bike:1:special_addons
 
 Sets have two ways to return one or more random members of a set:
 
-- [SPOP](https://redis.io/commands/spop)
-- [SRANDMEMBER](https://redis.io/commands/srandmember)
+- `SPOP`
+- `SRANDMEMBER`
 
 Each command takes a key and, optionally, a count as arguments. `SPOP` removes and returns a random member, whereas `SRANDMEMBER` just returns the randomly selected members without removing them.
 
@@ -63,4 +63,4 @@ SPOP bike:1:addons
 SMEMBERS bike:1:addons
 ```
 
-See [here](https://redis.io/commands/?group=set) for the entire list of Redis set-related commands.
+See [here](https://redis.io/docs/data-types/sets) for the set type reference page, and [here](https://redis.io/commands/?group=set) for the entire list of Redis set commands.

src/redis/working_with_sorted_sets.md

@@ -1,4 +1,7 @@
-Redis sets are unsorted, which limits their usefulness. [Sorted sets](https://redis.io/docs/data-types/sorted-sets) are similar to sets, except each unique member has an associated score, which provides the mechanism for sorting.
+Redis sets are unsorted, which limits their usefulness. Sorted sets are similar to sets, except each unique member has an associated score, which provides the mechanism for sorting. Use cases include:
+
+- rate limiters
+- game leaderboards
 
 The following example creates a set of bike brands named for famous computer programmers, using their birth year as the score element to sort the set.
 
@@ -13,12 +16,32 @@ ZADD bike:brands 1957 "Sophie Wilson"
 ZADD bike:brands 1912 "Alan Turing"
 ```
 
-Now you can use the [ZRANGE](https://redis.io/commands/zrange) command to retrieve members in the order of birth year.
+Now you can use the `ZRANGE` command to retrieve members in the order of birth year using member ranks as the arguments. As with lists, you can use `-1`, `-2`, etc., to represent the last, second to last, etc., members.
 
 ```redis ZRANGE usage
 ZRANGE bike:brands 2 4
 ```
 
-A popular use case for sorted sets is leaderboards for games.
+To delete members from a sorted set, use the `ZREM` command.
+
+```redis Remove the Alan Turing model and score
+ZREM bike:brands "Alan Turing"
+```
+
+Once all the members of a sorted set have been removed, the set's key will also be removed.
+
+To list all the members in score order, use the `ZRANGEBYSCORE`. If you pass the `WITHSCORES` argument, each member's score will also be listed.
+
+```redis List members ordered by score
+ZRANGEBYSCORE bike:brands -inf +inf WITHSCORES
+```
+
+Note the use of `-inf` and `+inf` in the previous example. This is useful when you don't readily know the score range or particular values. See the manual page for `ZRANGEBYSCORE` for more options.
+
+You can get the rank of any sorted set member using the `ZRANK` command. Note: the member with the lowest score has rank `0`.
+
+```redis Get a bike brand's rank
+ZRANK bike:brands "Claude Shannon" WITHSCORE
+```
 
-See [here](https://redis.io/commands/?group=sorted-set) for the entire list of Redis sorted set commands.
+See [here](https://redis.io/docs/data-types/sorted-sets) for the sorted set type reference page, and [here](https://redis.io/commands/?group=sorted-set) for the entire list of Redis sorted set commands.

src/redis/working_with_strings.md

@@ -1,18 +1,18 @@
-Redis [strings](https://redis.io/docs/data-types/strings) are used to store strings, numbers, and other kinds of information. They are the simplest of the Redis data types.
+Redis strings are used to store strings, numbers, images, serialized objects, and other kinds of information. They are the simplest of the Redis data types.
 
-As a first example, use the [SET](https://redis.io/commands/set/) command to store the value "Deimos", a type of bike, at key "bike:1".
+As a first example, use the `SET` command to store the value "Deimos", a type of bike, at key "bike:1".
 
 ```redis Create a new key
 SET bike:1 "Deimos"
 ```
 
-Redis will store the `bike:1` data permanently. You can retrieve the data using the [GET](https://redis.io/commands/get/) command.
+You can retrieve the data using the `GET` command.
 
 ```redis Retrieve the data
 GET bike:1
 ```
 
-To see if a key exists, use the [EXISTS](https://redis.io/commands/exists) command.
+To see if a key exists, use the `EXISTS` command.
 
 ```redis Do these keys exist?
 EXISTS bike:1
@@ -21,29 +21,40 @@ EXISTS bike:2
 
 The `EXISTS` command returns `1` when a key exists and `0` when it does not exist. The `bike:1` key exists, so Redis returns a value of `1`. The `bike:2` key does not exist, so Redis returns `0`.
 
-Use the [DEL](https://redis.io/commands/del) to delete a key and its data.
+Use the `DEL` to delete a key and its data.
+
+```redis Delete bike:1
+DEL bike:1
+EXISTS bike:1
+```
 
 ## Strings as counters
 
 If you store integer data in a string key, you can use these commands to increment and decrement its value:
 
-- [INCR](https://redis.io/commands/incr) - increment a number stored in a key by `1`.
-- [INCRBY](https://redis.io/commands/incrby) - increment a number stored in a key by a specific positive or negative amount.
-- [DECR](https://redis.io/commands/decr) - decrement a number stored in a key by `2`.
-- [DECRBY](https://redis.io/commands/decrby) - decrement a number stored in a key by a specific positive or negative amount.
+- `INCR` - increment a number stored in a key by `1`.
+- `INCRBY` - increment a number stored in a key by a specific positive or negative amount.
+- `DECR` - decrement a number stored in a key by `2`.
+- `DECRBY` - decrement a number stored in a key by a specific positive or negative amount.
 
-```redis INCR and DEL usage
+```redis INCR usage
 SET bikes:total_number 10
 INCR bikes:total_number
 INCR bikes:total_number
+```
+
+```redis Use INCR to set a key to 1
 DEL bikes:total_number
 INCR bikes:total_number
 ```
 
 Note how the `INCR bikes:total_number` command that follows the `DEL` command re-creates the `bikes:total_number` key and sets its value to `1`.
 
-```redis INCRBY, DECR, and DECRBY usage
+```redis INCRBY usage
 INCRBY bikes:total_number 100
+```
+
+```redis DECR and DECRBY usage
 DECR bikes:total_number
 DECRBY bikes:total_number 10
 ```
@@ -54,11 +65,11 @@ All the Redis operations implemented by single commands are atomic, including th
 
 ## Key expiration
 
-When keys are created without constraints, they live for the full lifespan of the Redis server to which they are attached. However, if you want a key to live for only a specific amount of time, you can use the [EXPIRE](https://redis.io/commands/expire) command to alter its lifespan. To find out how much time is left before a key expires, use the [TTL](https://redis.io/commands/ttl) command.
+When keys are created without constraints, they live for the full lifespan of the Redis server to which they are attached. However, if you want a key to live for only a specific amount of time, you can use the `EXPIRE` command to alter its lifespan. To find out how much time is left before a key expires, use the `TTL` command.
 
 ```redis EXPIRE usage
 SET bike:1:lock_status "LOCKED"
-EXPIRE bike:1:lock_status 120
+EXPIRE bike:1:lock_status 20
 ```
 
 After a few seconds, check the time-to-live status by running the `TTL` command.
@@ -79,22 +90,20 @@ SET bike:2:lock_status "LOCKED"
 TTL bike:2:lock_status
 ```
 
-`EXPIRE` and `TTL` operate in seconds, but there are analogous commands that operate in milliseconds. They are [PEXPIRE](https://redis.io/commands/pexpire) and [PTTL](https://redis.io/commands/pttl).
+`EXPIRE` and `TTL` operate in seconds, but there are analogous commands that operate in milliseconds. They are `PEXPIRE` and `PTTL`.
 
 The `SET` command can take additional arguments, one of which allows you to set the value of a key and its time to live value directly in a single, atomic operation. The `EX` and `PX` arguments allow you to specify the TTL value as either seconds or milliseconds, respectively.
 
 ```redis SET with time to live
 SET bike:1:lock_status "LOCKED" PX 1
 ```
 
-It's possible to cancel a key's timeout using the [PERSIST](https://redis.io/commands/persist) command.
+It's possible to cancel a key's timeout using the `PERSIST` command.
 
 ```redis PERSIST usage
 SET bike:1:lock_status "LOCKED" EX 120
 PERSIST bike:1:lock_status
 TTL bike:1:lock_status
 ```
 
-See the [SET](https://redis.io/commands/set) command manual page for more time-related and other arguments.
-
-See [here](https://redis.io/commands/?group=string) for the entire set of Redis string-related commands.
+See [here](https://redis.io/docs/data-types/strings) for the string type reference page, and [here](https://redis.io/commands/?group=string) for the entire set of Redis string commands.