Tweaks

Author: madeline-underwood

content/learning-paths/servers-and-cloud-computing/java-on-azure/background.md

@@ -6,13 +6,13 @@ weight: 2
 layout: "learningpathall"
 ---
 
-## Azure Cobalt 100 Arm‑based processor
+## Azure Cobalt 100 Arm-based CPU for Linux workloads
 
 Azure Cobalt 100 is Microsoft’s first‑generation, in‑house Arm‑based CPU built on Arm Neoverse N2. It is designed for predictable performance and energy efficiency across common Linux workloads such as web and application servers, analytics, open‑source databases, and caching systems. Each vCPU maps to a dedicated physical core and runs up to **3.4 GHz**, helping deliver consistent latency under load.
 
 Learn more in this Microsoft announcement blog: [Announcing the preview of new Azure VMs based on the Azure Cobalt 100 processor](https://techcommunity.microsoft.com/blog/azurecompute/announcing-the-preview-of-new-azure-vms-based-on-the-azure-cobalt-100-processor/4146353).
 
-## Java on Azure Cobalt 100
+## Running Java on Azure Cobalt 100 Arm-based VMs
 
 Java is a mature, object‑oriented language and runtime used to build scalable, secure applications. The Java Virtual Machine (JVM) executes platform‑independent bytecode, enabling *write once, run anywhere* portability across architectures, including Arm64 (AArch64). On Azure Cobalt 100, Java services benefit from modern JIT compilers and efficient multithreading for steady throughput and low tail latency.
 

content/learning-paths/servers-and-cloud-computing/java-on-azure/baseline.md

@@ -7,13 +7,13 @@ layout: learningpathall
 ---
 
 
-### Deploy a Java application with a Tomcat-like operation 
+## Deploy a Java application with a Tomcat-like operation 
 Apache Tomcat is a widely used Java web application server. Technically, it is a Servlet container, responsible for executing Java servlets and supporting technologies such as:
 
 - JSP (JavaServer Pages): Java-based templates for dynamic web content
-- RESTful APIs: Lightweight endpoints for modern microservices
+- RESTful APIs: lightweight endpoints for modern microservices
 
-In production, frameworks like Tomcat introduce additional complexity (request parsing, thread management, I/O handling). Before layering those components, it's useful to measure how efficiently raw Java executes simple request/response logic on Azure Cobalt 100 Arm-based instances.
+In production, frameworks like Tomcat introduce additional complexity (such as request parsing, thread management, and I/O handling). Before layering those components, it's useful to measure how efficiently raw Java executes simple request/response logic on Azure Cobalt 100 Arm-based instances.
 
 In this section, you will run a minimal Tomcat-like simulation. It won't launch a real server, but instead it will do the following:
 - Construct a basic HTTP response string in memory
@@ -40,21 +40,25 @@ public class HttpSingleRequestTest {
     }
 }
 ```
-## Compile and Run the Java program
+## Compile and run the Java program
+
+Compile the program and run it with modest heap sizes and the G1 garbage collector:
 
 ```console
 javac HttpSingleRequestTest.java
 java -Xms128m -Xmx256m -XX:+UseG1GC HttpSingleRequestTest
 ```
 
-## jvm flags explained
+## JVM flags explained
 
 - **-Xms128m** - sets the initial heap size to 128 MB
 - **-Xmx256m** - sets the maximum heap size to 256 MB
 - **-XX:+UseG1GC** - enables the G1 garbage collector designed for low pause times
 
 ## Sample output
 
+If the program runs successfully, you should see output similar to the following:
+
 ```output
 java -Xms128m -Xmx256m -XX:+UseG1GC HttpSingleRequestTest
 Response Generated:

content/learning-paths/servers-and-cloud-computing/java-on-azure/benchmarking.md

@@ -1,11 +1,12 @@
 
 ---
-title: Benchmark using JMH
+title: Benchmark using Java Microbenchmark Harness
 weight: 6 
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
+## Overview
 
 Now that you have built and run a Tomcat-like response in Java, the next step is to benchmark it using a reliable, JVM-aware framework.
 
@@ -81,6 +82,8 @@ This mirrors the Tomcat-like simulation you created earlier but now runs under J
 
 ## Build the benchmark JAR
 
+Build the project to produce the benchmark JAR:
+
 ```console
 mvn clean install -q
 ```
@@ -99,7 +102,7 @@ The output from this command should look like:
 
 After the build is complete, the JMH benchmark JAR will be located in the target directory.
 
-Run the Benchmark:
+Run the benchmark:
 
 ```console
 java -jar target/benchmarks.jar
@@ -215,32 +218,32 @@ MyBenchmark.benchmarkHttpResponse  thrpt   25  35659618.044 ± 686946.011  ops/s
 
 ## Benchmark metrics explained  
 
-- **Run Count**: The total number of benchmark iterations that JMH executed. More runs improve statistical reliability and help smooth out anomalies caused by the JVM or OS. 
-- **Average Throughput**: The mean number of operations completed per second across all measured iterations. This is the primary indicator of sustained performance for the benchmarked code.
-- **Standard Deviation**: Indicates the amount of variation or dispersion from the average throughput. A smaller standard deviation means more consistent performance.  
-- **Confidence Interval (99.9%)**: The statistical range in which the true average throughput is expected to fall with 99.9% certainty. Narrow confidence intervals suggest more reliable and repeatable measurements. 
-- **Min Throughput**: The lowest observed throughput across all iterations, representing a worst-case scenario under the current test conditions.
-- **Max Throughput**: The highest observed throughput across all iterations, representing the best-case performance under the current test conditions. 
+- **Run count** - the total number of benchmark iterations that JMH executed. More runs improve statistical reliability and help smooth out anomalies caused by the JVM or OS. 
+- **Average throughput** - the mean number of operations completed per second across all measured iterations. This is the primary indicator of sustained performance for the benchmarked code.
+- **Standard deviation** - indicates the amount of variation or dispersion from the average throughput. A smaller standard deviation means more consistent performance.  
+- **Confidence interval (99.9%)** - the statistical range in which the true average throughput is expected to fall with 99.9% certainty. Narrow confidence intervals suggest more reliable and repeatable measurements. 
+- **Min throughput** - the lowest observed throughput across all iterations, representing a worst-case scenario under the current test conditions.
+- **Max throughput** - the highest observed throughput across all iterations, representing the best-case performance under the current test conditions. 
 
-### Benchmark summary on Arm64
+## Benchmark summary on Arm64
 
 Here is a summary of benchmark results collected on an Arm64 **D4ps_v6 Ubuntu Pro 24.04 LTS virtual machine**.
 | Metric                        | Value |
 |--------------------------------|---------------------------|
-| **Java Version**               | OpenJDK 21.0.8            |
-| **Run Count**                  | 25 iterations             |
-| **Average Throughput**         | 35.66M ops/sec            |
-| **Standard Deviation**         | ±0.92M ops/sec            |
-| **Confidence Interval (99.9%)**| [34.97M, 36.34M] ops/sec  |
-| **Min Throughput**             | 33.53M ops/sec            |
-| **Max Throughput**             | 36.99M ops/sec            |
+| **Java version**               | OpenJDK 21.0.8            |
+| **Run count**                  | 25 iterations             |
+| **Average throughput**         | 35.66M ops/sec            |
+| **Standard deviation**         | ±0.92M ops/sec            |
+| **Confidence interval (99.9%)**| [34.97M, 36.34M] ops/sec  |
+| **Min throughput**             | 33.53M ops/sec            |
+| **Max throughput**             | 36.99M ops/sec            |
 
 
-### Key insights from the results
+## Key insights from the results
 
-- **Strong throughput performance** The benchmark sustained around 35.6 million operations per second, demonstrating efficient string construction and memory handling on the Arm64 JVM.
-- **Consistency across runs** With a standard deviation under 1 million ops/sec, results were tightly clustered. This suggests stable system performance without significant noise from background processes.
-- **High statistical confidence** The narrow 99.9% confidence interval ([34.97M, 36.34M]) indicates reliable, repeatable results. 
-- **Predictable performance envelope** The difference between min (33.5M) and max (37.0M) throughput is modest (~10%), suggests the workload performed consistently without extreme slowdowns or spikes.
+- **Strong throughput performance** - the benchmark sustained around 35.6 million operations per second, demonstrating efficient string construction and memory handling on the Arm64 JVM.
+- **Consistency across runs** - with a standard deviation under 1 million ops/sec, results were tightly clustered. This suggests stable system performance without significant noise from background processes.
+- **High statistical confidence** - the narrow 99.9% confidence interval ([34.97M, 36.34M]) indicates reliable, repeatable results. 
+- **Predictable performance envelope** - the difference between min (33.5M) and max (37.0M) throughput is modest (~10%), suggests the workload performed consistently without extreme slowdowns or spikes.
 
 The Arm-based Azure `D4ps_v6` VM provides stable and efficient performance for Java workloads, even in microbenchmark scenarios. These results establish a baseline you can now compare directly against x86_64 instances to evaluate relative performance.