edits

Author: ktoliver

articles/azure-cache-for-redis/cache-go-get-started.md

@@ -1,16 +1,15 @@
 ---
-title: Use Azure Cache for Redis with Go
+title: 'Quickstart: Use Azure Cache for Redis with Go'
 description: In this quickstart, you learn how to create a Go app that uses Azure Cache for Redis.
 
 
-
 ms.devlang: golang
 ms.topic: quickstart
 ms.date: 09/09/2021
 ms.custom: mode-api, devx-track-go
 ---
 
-# Quickstart: Use Azure Cache for Redis with Go
+# Quickstart: Use Azure Cache for Redis with a Go app
 
 In this article, you learn how to build a REST API in Go that stores and retrieves user information backed by a [HASH](https://redis.io/topics/data-types-intro#redis-hashes) data structure in [Azure Cache for Redis](./cache-overview.md).
 
@@ -22,24 +21,24 @@ If you want to go straight to the code, see the [Go quickstart sample](https://g
 
 ## Prerequisites
 
-- Azure subscription - [create one for free](https://azure.microsoft.com/free/)
+- Azure subscription. [Create one for free](https://azure.microsoft.com/free/)
 - [Go](https://go.dev/doc/install) (preferably version 1.13 or later)
 - [Git](https://git-scm.com/downloads)
-- An HTTP client like [cURL](https://curl.se/)
+- An HTTP client like [curlL](https://curl.se/)
 
 ## Create a cache
 
 [!INCLUDE [redis-cache-create](~/reusable-content/ce-skilling/azure/includes/azure-cache-for-redis/includes/redis-cache-create.md)]
 
 [!INCLUDE [redis-cache-create](includes/redis-cache-access-keys.md)]
 
-## Review the code (Optional)
+## Review the code (optional)
 
-If you're interested in learning how the code works, you can review the following snippets. Otherwise, feel free to skip ahead to [Run the application](#run-the-application).
+If you're interested in learning how the code works, you can review the following code snippets. Feel free to skip ahead to [Run the application](#run-the-application).
 
 The open source [go-redis](https://github.com/go-redis/redis) library is used to interact with Azure Cache for Redis.
 
-The `main` function starts off by reading the host name and password (Access Key) for the Azure Cache for Redis instance.
+The `main` function starts by reading the host name and password (access key) for the Azure Cache for Redis instance.
 
 ```go
 func main() {
@@ -48,7 +47,7 @@ func main() {
 ...
 ```
 
-Then, we establish connection with Azure Cache for Redis. We use [tls.Config](https://go.dev/pkg/crypto/tls/#Config)--Azure Cache for Redis only accepts secure connections with [TLS 1.2 as the minimum required version](cache-remove-tls-10-11.md).
+Then, you establish connection with Azure Cache for Redis. We use [tls.Config](https://go.dev/pkg/crypto/tls/#Config)--Azure Cache for Redis only accepts secure connections with [TLS 1.2 as the minimum required version](cache-remove-tls-10-11.md).
 
 ```go
 ...
@@ -63,10 +62,10 @@ if err != nil {
 ...
 ```
 
-If the connection is successful, [HTTP handlers](https://go.dev/pkg/net/http/#HandleFunc) are configured to handle `POST` and `GET` operations and the HTTP server is started.
+If the connection is successful, [HTTP handlers](https://go.dev/pkg/net/http/#HandleFunc) are configured to handle `POST` and `GET` operations, and the HTTP server is started.
 
 > [!NOTE]
->The [gorilla mux library](https://github.com/gorilla/mux) is used for routing (although it's not strictly necessary, and using the standard library for this sample application is an option).
+>The [gorilla mux library](https://github.com/gorilla/mux) is used for routing (although it's not required, and using the standard library for this sample application is an option).
 >
 
 ```go
@@ -79,7 +78,7 @@ router.HandleFunc("/users/{userid}", uh.getUser).Methods(http.MethodGet)
 log.Fatal(http.ListenAndServe(":8080", router))
 ```
 
-The `userHandler` struct encapsulates a [redis.Client](https://pkg.go.dev/github.com/go-redis/redis/v8#Client). The `createUser` and `getUser` methods use the redis.Client. For brevity, the code for these methods isn't included in this article.
+The `userHandler` struct encapsulates [redis.Client](https://pkg.go.dev/github.com/go-redis/redis/v8#Client). The `createUser` and `getUser` methods use redis.Client. For brevity, the code for these methods isn't included in this article.
 
 - `createUser`: Accepts a JSON payload (that has user information) and saves it as a `HASH` in Azure Cache for Redis.
 - `getUser`: Fetches user info from `HASH` or returns an HTTP `404` response if it's not found.
@@ -126,22 +125,24 @@ Start by cloning the application on GitHub:
 
 The application accepts connectivity and credentials in the form of environment variables.
 
-1. In the [Azure portal](https://portal.azure.com/), get the host name and access keys for the Azure Cache for Redis instance.
+1. In the [Azure portal](https://portal.azure.com/), get the host name and access key for the instance of Azure Cache for Redis.
 
-1. Set them to the respective environment variables:
+1. Set the host name and access key to the following environment variables:
 
     ```console
     set REDIS_HOST=<Host name>:<port> (for example, <name of cache>.redis.cache.windows.net:6380)
     set REDIS_PASSWORD=<Primary Access Key>
     ```
 
-1. In the terminal window, change to the correct folder. For example:
+1. In the terminal, go to the folder you created for the samples:
+
+   For example:
 
     ```console
     cd "C:\git-samples\azure-redis-cache-go-quickstart"
     ```
 
-1. In the terminal, run the following command to start the application.
+1. In the terminal, start the application by using this command:
 
     ```console
     go run main.go
@@ -151,23 +152,23 @@ The HTTP server starts on port `8080`.
 
 ## Test the application
 
-1. Create a few user entries. 
+1. Create a few user entries.
 
-   The following example uses cURL:
+   The following example uses curl:
 
     ```bash
     curl -i -X POST -d '{"id":"1","name":"foo1", "email":"[email protected]"}' localhost:8080/users/
     curl -i -X POST -d '{"id":"2","name":"foo2", "email":"[email protected]"}' localhost:8080/users/
     curl -i -X POST -d '{"id":"3","name":"foo3", "email":"[email protected]"}' localhost:8080/users/
     ```
 
-1. Fetch an existing user by using the value for the `id`:
+1. Fetch an existing user by using the value for `id`:
 
     ```bash
     curl -i localhost:8080/users/1
     ```
 
-    The output is JSON response that is similar to this example:
+    The output is a JSON response that's similar to this example:
 
     ```json
     {
@@ -177,7 +178,7 @@ The HTTP server starts on port `8080`.
     }
     ```
 
-1. If you try to fetch a user who doesn't exist, you get an HTTP `404`.
+1. If you try to fetch a user who doesn't exist, you get an HTTP `404` error message.
 
    For example:
 
@@ -199,5 +200,6 @@ The HTTP server starts on port `8080`.
 
 In this quickstart, you learned how to get started using Go with Azure Cache for Redis. You configured and ran a simple REST API-based application to create and get user information backed by a Redis `HASH` data structure.
 
-> [!div class="nextstepaction"]
-> [Create a simple ASP.NET web app that uses an Azure Cache for Redis.](./cache-web-app-howto.md)
+## Related content
+
+- [Create a simple ASP.NET web app that uses Azure Cache for Redis.](./cache-web-app-howto.md)

articles/azure-cache-for-redis/cache-java-get-started.md

@@ -10,13 +10,13 @@ ms.devlang: java
 ms.custom: devx-track-java, devx-track-javaee, mode-api, mvc, devx-track-extended-java
 ---
 
-# Quickstart: Use Azure Cache for Redis in Java
+# Quickstart: Use Azure Cache for Redis in a Java app
 
 In this quickstart, you incorporate Azure Cache for Redis into a Java app by using the [Jedis](https://github.com/xetorthio/jedis) Redis client. Your cache is a secure, dedicated cache that is accessible from any application within Azure.
 
 ## Skip to the code
 
-This article describes how to create an app by using the Azure portal and then modify the code to end up with a working sample app.
+This quickstart uses the Maven archetype feature to generate scaffolding for the app. The quickstart describes how to modify the generated code to end up with a working sample app.
 
 If you want to go straight to the code, see the [Java quickstart sample](https://github.com/Azure-Samples/azure-cache-redis-samples/tree/main/quickstart/java) on GitHub.
 
@@ -33,7 +33,7 @@ If you want to go straight to the code, see the [Java quickstart sample](https:/
 
 ## Set up the working environment
 
-Depending on your operating system, add environment variables for your **Host name** and **Primary access key** that you noted previously. Open a command prompt, or a terminal window, and set up the following values:
+Depending on your operating system, add environment variables for host name and primary access key that you noted earrlier. In a command prompt or a terminal window, set up the following values:
 
 ### [Linux](#tab/bash)
 
@@ -53,16 +53,16 @@ set REDISCACHEKEY=<your-primary-access-key>
 
 Replace the placeholders with the following values:
 
-- `<your-host-name>`: The DNS host name, obtained from the *Properties* section of your Azure Cache for Redis resource in the Azure portal.
-- `<your-primary-access-key>`: The primary access key, obtained from the *Access keys* section of your Azure Cache for Redis resource in the Azure portal.
+- `<your-host-name>`: The DNS host name, obtained from the **Properties** section of your Azure Cache for Redis resource in the Azure portal.
+- `<your-primary-access-key>`: The primary access key, obtained from the **Access keys** section of your Azure Cache for Redis resource in the Azure portal.
 
 ## Understand the Java sample
 
 In this sample, you use Maven to run the quickstart app.
 
-1. Change to the new *redistest* project directory.
+1. Go to the new *redistest* project directory.
 
-1. Open the *pom.xml* file. In the file, you see a dependency for [Jedis](https://github.com/xetorthio/jedis):
+1. Open the *pom.xml* file. In the file, verify that a dependency for [Jedis](https://github.com/xetorthio/jedis) appears:
 
     ```xml
     <dependency>
@@ -76,7 +76,7 @@ In this sample, you use Maven to run the quickstart app.
 
 1. Close the *pom.xml* file.
 
-1. Open *App.java* and see the code with the following code:
+1. Open *App.java* and verify that the following code appears:
 
     ```java
     package example.demo;
@@ -103,7 +103,7 @@ In this sample, you use Maven to run the quickstart app.
                 .ssl(useSsl)
                 .build());
 
-            // Perform cache operations using the cache connection object...
+            // Perform cache operations by using the cache connection object. 
 
             // Simple PING command
             System.out.println( "\nCache Command  : Ping" );
@@ -129,13 +129,13 @@ In this sample, you use Maven to run the quickstart app.
     }
     ```
 
-    This code shows you how to connect to an Azure Cache for Redis instance using the cache host name and key environment variables. The code also stores and retrieves a string value in the cache. The `PING` and `CLIENT LIST` commands are also executed.
+    This code shows you how to connect to an Azure Cache for Redis instance by using the cache host name and key environment variables. The code also stores and retrieves a string value in the cache. The `PING` and `CLIENT LIST` commands are also executed.
 
-1. Close the *App.java*.
+1. Close *App.java*.
 
 ## Build and run the app
 
-1. First, if you haven't already, you must set the environment variables as noted previously.
+1. Set the environment variables as noted earlier:
 
    ### [Linux](#tab/bash)
 
@@ -153,7 +153,7 @@ In this sample, you use Maven to run the quickstart app.
 
     ---
 
-1. Execute the following Maven command to build and run the app:
+1. To build and run the app, run the following Maven command:
 
    ### [Linux](#tab/bash)
 
@@ -171,7 +171,7 @@ In this sample, you use Maven to run the quickstart app.
 
     ---
 
-In the following output, you can see that the `Message` key previously had a cached value. The value was updated to a new value using `jedis.set`. The app also executed the `PING` and `CLIENT LIST` commands.
+In the following output, you can see that the `Message` key previously had a cached value. The value was updated to a new value by using `jedis.set`. The app also executed the `PING` and `CLIENT LIST` commands.
 
 ```output
 Cache Command  : Ping
@@ -196,8 +196,6 @@ Cache Response : id=777430 addr=             :58989 fd=22 name= age=1 idle=0 fla
 
 ## Related content
 
-In this quickstart, you learned how to use Azure Cache for Redis from a Java application. Continue to the next quickstart to use Azure Cache for Redis with an ASP.NET web app.
-
 - [Development](cache-best-practices-development.md)
 - [Connection resilience](cache-best-practices-connection.md)
 - [Azure Cache for Redis with Jakarta EE](/azure/developer/java/ee/how-to-deploy-java-liberty-jcache)