second pass

Author: anupras-mohapatra-arm

content/learning-paths/servers-and-cloud-computing/benchmark-nlp/_index.md

@@ -33,8 +33,7 @@ generated_summary_faq:
     with PyTorch on Arm servers and measure how they perform. Starting from a working Ubuntu
     22.04 Arm environment, you'll run three NLP models with the Sentiment Analysis
     pipeline, record baseline results, and then enable BFloat16 fast math kernels to assess the
-    impact on inference performance. The workflow is validated on Arm Neoverse-based AWS Graviton3
-    (c7g) instances and remains applicable to Arm servers meeting the stated requirements. By
+    impact on inference performance. By
     the end, you'll compare before-and-after measurements to confirm the effect of BFloat16
     on this workload.
   faqs:

content/learning-paths/servers-and-cloud-computing/bolt-demo/_index.md

@@ -41,7 +41,7 @@ generated_summary_faq:
     release, set up a working directory, and gather profiles with BRBE, SPE, instrumentation,
     or PMU sampling. Using a small set of Arm TopDown indicators, you'll judge
     whether a program is front-end bound and a good candidate for BOLT. You'll then run BOLT with
-    collected profiles to reorganize code layout and then evaluate the impact using performance
+    collected profiles to reorganize code layout and evaluate the impact using performance
     metrics and profiling data to confirm improvements in instruction delivery and locality.
   faqs:
   - question: Which BOLT version should I use if my package manager installs an older release?
@@ -50,7 +50,7 @@ generated_summary_faq:
       prebuilt LLVM release instead (for example, LLVM 22.1.5) to match the required features.
   - question: Where do the example’s build and profiling outputs go?
     answer: >-
-      The path organizes outputs into three directories: out for binaries, prof for profile data,
+      You'll find outputs into three directories: out for binaries, prof for profile data,
       and heatmap for visualization artifacts. Keeping these separate makes it easier to rerun
       steps and compare results.
   - question: How do I know if my program is a good candidate for BOLT?
@@ -61,7 +61,7 @@ generated_summary_faq:
   - question: What should I use if my kernel does not meet the BRBE or SPE requirements?
     answer: >-
       If your kernel is older than the BRBE requirement, use SPE if the kernel meets the SPE version
-      requirement. If neither is available, the path also covers using instrumentation or PMU
+      requirement. If neither is available, you can use instrumentation or PMU
       event sampling to collect profiles.
   - question: What result should I expect after running BOLT with profiles?
     answer: >-

content/learning-paths/servers-and-cloud-computing/bolt-merge/_index.md

@@ -33,26 +33,26 @@ generated_summary_faq:
   summary: >-
     You'll use BOLT with Linux Perf profiles to optimize an Arm application
     and its shared libraries. First, you'll instrument a MySQL server build to generate workload-specific
-    profiles, create separate traces for read- and write-heavy runs, and merge them to broaden
-    code layout guidance. Then, you'll rebuild OpenSSL to make libssl.so and
-    libcrypto.so suitable for BOLT, collect profiles, and apply optimizations independently
+    profiles, create separate traces for read-heavy and write-heavy runs, and merge them to broaden
+    code layout guidance. Then, you'll rebuild OpenSSL to make `libssl.so` and
+    `libcrypto.so` suitable for BOLT, collect profiles, and apply optimizations independently
     from the main binary. Finally, you'll compare results across baseline, isolated, and merged
     scenarios using a consistent Sysbench configuration to assess the
     impact of application and library-level optimizations on throughput and latency.
   faqs:
   - question: What output should I expect after running an instrumented workload with BOLT?
     answer: >-
-      BOLT produces a profile file in .fdata format, such as profile-writeonly.fdata. These files
+      BOLT produces a profile file in `.fdata` format, such as `profile-writeonly.fdata`. These files
       are later used to optimize the binary and can be merged to improve coverage.
   - question: Should I reuse the BOLT-instrumented mysqld binary for additional workloads or create
       a new one?
     answer: >-
       Either approach works. The steps allow reusing the previously instrumented binary or generating
-      a new instrumented variant as long as you produce a new .fdata profile for each workload.
+      a new instrumented variant as long as you produce a new `.fdata` profile for each workload.
   - question: Which shared libraries are targeted for optimization, and what if the system copies
       are stripped?
     answer: >-
-      The path optimizes libssl.so and libcrypto.so. If system libraries are stripped, rebuild
+      The path optimizes `libssl.so` and `libcrypto.so`. If system libraries are stripped, rebuild
       OpenSSL from source with relocations enabled so BOLT can instrument and optimize them.
   - question: Do I need to rebuild the application to benefit from optimized shared libraries?
     answer: >-
@@ -61,7 +61,7 @@ generated_summary_faq:
       with the application.
   - question: What test configuration is used to compare baseline and BOLT-optimized results?
     answer: >-
-      Sysbench is run with --time=0 --events=10000 to complete exactly 10,000 requests per thread.
+      Sysbench is run with `--time=0 --events=10000` to complete exactly 10,000 requests per thread.
       Use this consistent configuration to compare baseline, application-only, and merged-with-library
       optimization scenarios.
 # END generated_summary_faq

content/learning-paths/servers-and-cloud-computing/bolt/_index.md

@@ -32,7 +32,7 @@ generated_summary_faq:
   summary: >-
     You'll use BOLT to post-link optimize an Arm Linux executable
     based on real execution profiles. First, you'll prepare a target system for profiling and optionally
-    a separate build/BOLT system, then choose a profiling method—Perf samples, ETM, or SPE—to
+    a separate build/BOLT system, then choose a profiling method — Perf samples, ETM, or SPE — to
     collect runtime behavior into a perf.data file. You'll convert the profile for BOLT, and run BOLT to reorder code layout and emit a new optimized executable. By the end, you'll make an informed choice about how to collect profiles, produce the expected artifacts,
     and run the optimization steps in sequence so the resulting binary can be compared against
     the original to observe improvements.

content/learning-paths/servers-and-cloud-computing/buildkite-gcp/_index.md

@@ -38,15 +38,14 @@ generated_summary_faq:
     Axion, install Docker, Docker Buildx, and the Buildkite agent, and connect the agent to a
     Buildkite queue. First, you'll create a small Flask application and Dockerfile in a GitHub repository,
     then configure a Buildkite pipeline that uses Buildx to build a multi-architecture container
-    image for Arm and x86 and push it to Docker Hub. You'll use Ubuntu or SUSE on the VM
+    image,and push it to Docker Hub. You'll use Ubuntu or SUSE on the VM
     and validate that the agent is online. By the end, you'll have a published
     image and a running Flask service to confirm the build.
   faqs:
   - question: Which Google Cloud instance type and OS should I use for the VM?
     answer: >-
-      The steps use a Google Axion C4A Arm VM, specifically `c4a-standard-4` with 4 vCPUs and 16
-      GB memory. You can select either Ubuntu or SUSE Linux Enterprise Server as shown in the
-      installation instructions.
+      Use a Google Axion C4A Arm VM, specifically `c4a-standard-4` with 4 vCPUs and 16
+      GB memory. You can select either Ubuntu or SUSE Linux Enterprise Server as the OS.
   - question: Where do I create the Buildkite agent token, and when do I use it?
     answer: >-
       Create an agent token in your Buildkite organization after signing in (GitHub sign-in is
@@ -55,11 +54,11 @@ generated_summary_faq:
   - question: How do I confirm the Buildkite agent is connected and assigned to the right queue?
     answer: >-
       After configuring the agent and queue, check the Agents page in Buildkite; the agent should
-      appear online with the expected queue. If it does not, check the agent configuration and
+      appear online with the expected queue. If it doesn't, check the agent configuration and
       queue name, then repeat the verification step.
   - question: What files should my GitHub repository contain for the example application?
     answer: >-
-      Add a Dockerfile and a Python file named app.py. The provided Dockerfile uses `python:3.12-slim`,
+      Add a Dockerfile and a Python file named `app.py`. The provided Dockerfile uses `python:3.12-slim`,
       installs Flask, exposes port 5000, and runs the app.
   - question: What result should I expect after the pipeline runs successfully?
     answer: >-

content/learning-paths/servers-and-cloud-computing/cassandra-on-gcp/_index.md

@@ -32,13 +32,13 @@ generated_summary_faq:
   faq_source_hash: b8268d4df3b62aeb9943b750b436a936134d47745fa71db6cc08db8c84eb37be
   summary: >-
     You'll deploy Apache Cassandra on Arm-based Google
-    Cloud Axion C4A virtual machines and validating a working baseline before running simple workload
-    tests. First, you'll create a `c4a-standard-4` instance in the Google Cloud console, install Cassandra
-    on Ubuntu or SUSE, and satisfy the Java requirement. Then, you'll start Cassandra as a background
+    Cloud Axion C4A virtual machines and validate a working baseline before running simple workload
+    tests. First, you'll create a `c4a-standard-4` instance in the Google Cloud console and install Cassandra
+    on Ubuntu or SUSE. Then, you'll start Cassandra as a background
     service, with logs tailed to confirm “Startup complete,” followed by nodetool status to verify
     the node state. By the end, you'll benchmark using the built-in `cassandra-stress` utility
     to exercise write, read, and mixed operations on Arm64 to
-    confirm Cassandra is operating correctly on Axion-based instances.
+    confirm Cassandra is operating correctly.
   faqs:
   - question: Which Google Cloud machine type should I choose for this setup?
     answer: >-

content/learning-paths/servers-and-cloud-computing/cca-container/_index.md

@@ -43,7 +43,7 @@ generated_summary_faq:
     answer: >-
       Pull `armswdev/cca-learning-path:cca-simulation-v3`. Run `docker image list` and check that
       this repository and tag appear in the output.
-  - question: What result should I expect when the Realm guest VM starts?
+  - question: What result should I expect when the Realm guest virtual machine starts?
     answer: >-
       The guest virtual machine (VM) should boot as a Realm and run guest Linux. Continue when the
       VM is up and ready for the application injection step.

content/learning-paths/servers-and-cloud-computing/cca-device-attach/_index.md

@@ -40,7 +40,7 @@ generated_summary_faq:
     when devices can't DMA directly to Realm memory. You'll also explore how PCIe‑TDISP and PCIe‑IDE
     provide secure device attach with attestation. Then, you'll run a pre-built Key Broker
     demo inside a Realm and use kernel tracing to observe SWIOTLB activity during VirtIO network
-    I/O. By the end, you can recognize when data paths rely on bounce buffers and how this relates
+    I/O. By the end, you'll recognize when data paths rely on bounce buffers and how this relates
     to the chosen device attach method.
   faqs:
   - question: How do I know that bounce buffers are being used in the Realm?

content/learning-paths/servers-and-cloud-computing/cca-essentials/_index.md

@@ -31,7 +31,7 @@ generated_summary_faq:
   faq_generated_at: '2026-06-30T21:42:00Z'
   faq_source_hash: ba896cb418c6ae4f96029081ac9ef1f9193e8983425ad7a316c184b5b6017fbf
   summary: >-
-    You'll deploy a simple workload in a Linux realm on
+    You'll deploy a sample workload in a Linux realm on
     an Armv9-A AEM Base Fixed Virtual Platform (FVP) with Realm Management Extension (RME) support
     and connect it to attestation services to control access to secrets. First, you'll start a minimal
     Key Broker Server (KBS) from the Veraison project in a container, then integrate it with the

content/learning-paths/servers-and-cloud-computing/cca-kata/_index.md

@@ -35,8 +35,8 @@ generated_summary_faq:
     First, you'll learn about the Confidential Containers design, understand which components run inside the
     Trusted Execution Environment, and see how Trustee services (AS, KBS, RVPS) use Arm CCA
     attestation to authorize decryption. Then, you'll start the Trustee services and a local Docker
-    registry, publish an encrypted image, and launch the container on the FVP. By the end, you'll confirm attestation, key release, and that the workload runs in a Realm only
-    after authorization, completing an end-to-end confidential execution workflow.
+    registry, publish an encrypted image, and launch the container on the FVP. By the end, you'll complete an end-to-end confidential execution workflow and confirm attestation, key release, and that the workload runs in a Realm only
+    after authorization.
   faqs:
   - question: How do I know the Trustee services are ready before pushing the image?
     answer: >-